JAVA学习Day9【面对对象3】
学习视频：https://www.bilibili.com/video/BV17J411G72L?p=20163-176
/*
*包作用：（1）避免重名（2）分类组织管理众多的类（3）用于访问权限控制
*声明包要求（1）一个源文件.java只能有一句 （2）习惯上用公司的域名倒置+模块名（com商业 org非营利性 gov政府edu教育）
*如何使用其他包的类
*前提：被使用的类或成员的权限修饰词需要允许跨包使用
*方式：（1）使用全名称：包.类名(2)使用import语句 + 简名（写在package和class之间）
*当语句可以有很多句，导不同包的类
*java.lang包中类可以不使用import语句，直接使用简名称 System String Math...
*如果出现不同包，但是类名相同，只能一个使用简名称一个使用全名称，不能同时使用简名称
*
*/
//文件1
package com.atguigu.pkg //文件名package/com/下的pkg文件
import com.atguigu.bean.Rectangle
//import com.atguigu.bean.*
class test09_01{
public static void main(String[] args){
System.out.println("dfd");
com.atguigu.bean.Circle c1 = new com.atguigu.pkg.Circle();
c1.printInfo();
Rectangle r1 = new Rectangle();
}
}
//文件2
package com.atguigu.bean
public class test09_02{
public static void main(String[] args){
private double radius;
public Circle(){
}
public Circle(double r){
radius = r
}
public void printInfo(){
System.out.printIn(r);
}
}
}
package com.atguigu.bean
public class Rectangle{
private double length;
private double width;
public Rectangle(){
}
public Rectangle(double chang, double kuan){
length = chang;
width = kuan;
}
public void printInfo(){
System.out.println(length + " " + width);
}
}
//统一用utf-8编码
/*
*快捷键ctrl + Y ： 反撤销
*Alt + / ： 内容提示
*ctrl + 1 ： 快速修复
*快速导包：Ctrl + shift + o
*快速复制一行：选中块 ctrl + alt + 上箭头（下箭头）
*快速格式化 ctrl + shift + f
*查看某个类的源代码文件：（1）选中类，按ctrl 单击 （2）ctrl + shift + T 输入类名打开
*多行同时编辑：Alt + Shift + A
*/
/*
*自动生成代码：1.构造器 2.get/set
*Alt + Shift + S 或者选Source菜单
*（1）构造器 Generate Constructor Using Fields...
*（2）get/set Generate Getters And Setters...
*/
/*
*this 当前对象
*（1）构造器：正在创建的对象
*（2）方法：正在调用该方法的对象
*用法：
*（1）this.属性：当局部变量和成员变量同名时，可以在成员变量的前面加this
*（2) this.方法没有非用不可的时候
*（3）this()或this(实参列表)
*this()表示调用本类的无参构造
*this()必须在首行
*this(实参列表)调用有参列表
*/
class test09_04{
public static void main(String[] args){
Circle c1 = new Circle(1.2);
c1.setRadius(2.1);
}
}
class Circle{
private double radius;
public Circle(){
System.out.println("dfdfd");//用法（3）
}
public Circle(double radius){
this();//用法（3）
this.radius = radius;//用法（1）
}
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;//没有同名问题可以不加this
//return this.radius;
}
public double getArea(){
return 3.14 * radius * radius;
}
public void printInfo(){
System.out.println(radius + " " + getArea());
//System.out.println(this.radius + " " + this.getArea());//用法（2）
}
}
class Student{
private String name;
private int age;
private char gender;
private int score;
public Student(){
}
public Student(String name, int age){
this.name = name;
this.age = age;
}
public Student(String name, int age, char gender, int score){
this(name, age);
//this.name = name;
//this.age = age;
this.gender = gender;
this.score = score;
}
}
/*
*继承
*(1)延续
*(2)扩展
*为什么要有继承：
*（1）当某个类，需要派生出很多子类别
*如Person需要派生出Teacher、Student等等子类，那么Person中共有的部分就不需要在子类别中再次声明
*（2）当多个类中出现共同的特征时，可以吧共同的部分提取到父类中
*子类：subclass也称派生类
*父类：superclass也称超类或基类
*继承的特点：（1）子类继承了父类
*从事物的特征来说，子类会继承父类的所有特征
*但是从代码操作的角度说，父类中私有的属性、方法在子类中是不能直接使用的
*（2）子类继承父类时，构造器是不能被继承的！！！！！！！！！！！！！！！！！！！！！！！
*（3）子类继承父类时，在子类的构造器中一定要去调用父类的构造器
*默认情况下，调用的父类无参的构造器
*如果父类没有无参构造，则在子类的构造器的首行，必须手动调用父类的有参构造
*（4）JAVA只支持单继承
*（5）JAVA支持多层继承，即父类还有父类
*（6）一个JAVA类可以同时有很多个子类，而且子类还可以有子类
*（7）子类可以扩展父类没有的属性、方法
*/
public class test09_05{
public static void main(String[] args){
Teacher t = new Teacher();
t.setName("dfd");
t.setAge(18);
//Teacher t2 = new Teacher("fd", 21);不能直接调用父类的私有构造器，根据继承的特点（2）
}
}
class Person{
private String name;
private int age;
public Person(){
}
public Person(String name, int age){
this.name = name;
this.age = age;
}
public void setName(string name){
this.name = name;
}
public string getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
class Teacher extends Person{
private double salary;
//public void test(){
//System.out.println(name);不能使用
//}
public Teacher(){
super(null, 0);//默认值
}
public Teacher(String name, int age, double salary){
super(name, age);//感觉和this(参数列表)的用法相似
//根据继承的特征（3），这里super必须在首行
this.salary = salary;
}
}
class Student extends Person{
private int score;
}
class Student extends Person{
}
/*
*方法的重写
*当子类继承了父类的方法时，但是父类的方法体不适用子类，可重写
*要求：（1）方法名必须与父类被重写的方法名相同
*（2）形参列表，必须和父类被重写的形参列表相同
*（3）返回值类型：基本数据类型和void要求与父类被重写的方法的返回值类型相同
*引用数据类型，要求子类重写的方法的返回值类型 <= 父类被重写的方法的返回值类型
*例如子类方法的返回值是Student，父类被重写方法的返回值类型是Student
*（4）修饰符
*1.权限修饰符，子类重写的方法的权限修饰符的可见范围 >= 父类被重写方法的权限修饰符的可见性范围
*例如：子类方法的修饰符是public，父类被重写方法的修饰符是protected
*2.其他修饰符（之后讲）
*/
public class test09_06{
public static void main(String[] args){
Manager m = new Manager("dfdf", 11, 23);
System.out.println(m.getInfo());
}
}
class Employee{
//属性列表
private String name;
private double salary;
//构造器
public Employee(){
}
public Employee(String name, double salary){
super();
this.name = name;
this.salary = salary;
}
//get、set
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public double getSalary(){
return name;
}
public void setSalary(double salary){
this.salary = salary;
}
public String getInfo(){
return "姓名： " + name + "工资： " + salary;
}
}
class Manager extends Employee{
//属性列表
private double bonus;
//构造器
public Manager(){
}
public Manager(String name, double salary, double bonus){
super(name, salary);
this.bonus = bonus;
}
//get、set
public void setBonus(double bonus){
this.bonus = bonus;
}
public double getBonus(){
return bonus;
}
//重写
public String getInfo(){
return "姓名： " + getName() + "工资： " + getSalary() + "奖金： " + bonus;
}
}
/*
*Super 从父类中查找，引用父类的某某
*只能访问在父类中可见的属性、方法、构造器
*用法：1.super.属性当子类声明了和父类同名的属性时，可以使用super属性来访问父类的属性
*2.super.方法
*当子类中需要调用父类被重写的方法时，可以使用super.方法
*3.super()或super(实参列表)
*super()调用父类的无参结构
*super(参数列表)调用父类的有参结构
*必须在子类构造器的首行
*如果子类的构造器中没有写super()，它也存在
*但如果子类构造器中写了super(实参列表)，那么super()就不会存在了
*/
public class test09_06{
public static void main(String[] args){
B b = new B();
b.printNum(3);
}
}
class A{
int num = 1;
}
class B extneds A{
int num = 2;
public void printNum(int num){
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
class Human{
//属性
private String name;
private int age;
//构造器
public Human(String name, int age){
super();//调用的是公共父类java.lang.Object类的无参构造
this.name = name;
this.age = age;
}
public Human(){
}
//get、set
pulic String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
pulic String getAge(){
return Age;
}
public void setAge(int Age){
this.Age = Age;
}
//方法
public String getInfo(){
return "姓名:" + name + "年龄:" + age;
}
}
class XueSheng extends Human{
private int score;
//.......
public String getInfo(){
return super.getInfo() + "成绩：" + score；
}
}
页:
[1]