JAVA基础3（面向对象）

六、面向对象
1、类和对象
　（1）类：是对一类事物的抽象描述
　　　 类的组成： public class Teacher {
　　　　　　　　　　　　 //静态特点：属性（成员变量）
　　　　　　　　　　　　 String name;
　　　　　　　　　　　　 //动态行为：方法（成员方法）
　　　　　　　　　　　　 public void show(){
　　　　　　　　　　　　　　 System.out.println(“姓名：”+name);
　　　　　　　　　　　　 }
　　　　　　　　　 }
　 （2）对象：是类的实例化，是一个具体的实体，万物皆为对象
　　　 对象实例化： public class Teachers {
　　　　　　　　　　　　 public static void main(String[] args){
　　　　　　　　　　　　　　 //以类为模板创建实例对象：类名 对象名=new 类名（）
　　　　　　　　　　　　 　　Teacher people1=new Teacher();//左边的类名为对象的数据类型；右边的类名()成为类的构造方法
　　　　　　　　　　　　　　 //给属性赋值：对象.属性名
　　　　　　　　　　　　　　 people1.name=“张三”;
　　　　　　　　　　　　　　 //调用方法：对象.方法名
　　　　　　　　　　　　　　 people1.show();
　　　　　　　　　　　　　 }
　　　　　　　　　　 }
2、方法组成
　 访问修饰符 返回值类型 方法名(参数列表){ 方法体 }
　 （1）访问修饰符
　　　　 private：是私有的， 同类中使用
　　　　 默认： 　　　　　　 同类、同包类中使用
　　　　 protected：受保护的，同类、同包类、子类中使用
　　　　 public：公共的， 　　同类、同包类、子类、任何地方中使用
　 （2）返回值类型
　　　 1>无返回值类型：void
　　　　　 public class Student {
　　　　　　　 String name;
　　　　　　　 public void show(){
　　　　　　　　　 System.out.println(name);
　　　　　　　 }
　　　　　　　 public static void main(String[] args){
　　　　　　　　　 Student stu=new Student();
　　　　　　　　　 stu.name=“张三”;l
　　　　　　　　　 stu.show();
　　　　　　　 }
　　　　　 }
　　　 2>有返回值类型（必须配合return使用）：int double String int[]···
　　　　　public class Student {
　　　　　　　 String name;
　　　　　　　 public String name(){
　　　　　　　　　 return name;
　　　　　　　 }
　　　　　　　 public static void main(String[] args){
　　　　　　　　　 Student stu=new Student();
　　　　　　　　　 stu.name=“张三”;
　　　　　　　　　String stuname=stu.name();
　　　　　　　　　 System.out.println(stuname);
　　　　　　　　 }
　　　　　 }
　 （3）return作用：返回结果 跳出方法（可用于跳出多重循环）
　 （4）方法调用（注：调用的方法有无返回值，有无参数）
　　　　 1>同一个类中方法间相互调用，直接方法名()调用
　　　　　 public class Student {
　　　　　　　 String name;
　　　　　　　 public String name(){
　　　　　　　　　 return name;
　　　　　　　 }
　　　　　　　 public String print(){
　　　　　　　　　 String userName=name();
　　　　　　　　 }
　　　　　 ｝
　　　 2>不同类中方法调用，需要先创建对象然后再用对象名.方法名()调用
　 （5）成员变量和局部变量(可以重名，使用时局部变量优先级更高)
　　　 1>成员变量有默认值，作用于整个类
　　　 2>局部变量没有默认值，作用于方法内
　 （6）成员方法
　　　1>无参方法：访问修饰符 返回值类型 方法名(){方法体}
　　　　 public String name(){
　　　　　　 return name;
　　　　 }
　　　 2>带参方法：访问修饰符 返回值类型 方法名(参数列表){方法体}
　　　　 public String name(String userName,int born){
　　　　　　 return userName+born+“年”;
　　　　 }
　　　　 public static void main(String[] args){
　　　　　　 Scanner input=new Scanner(System.in);
　　　　　　Student stu=new Student();
　　　　　　 String stuName=input.next();
　　　　　　 int bornTime=input.nextInt();
　　　　　　String stuNameBorn=stu.name(stuName,bornTime);
　　　　　　System.out.println(stuNameBorn);
　　　　 }
　 （7）参数列表
　　　 1>形参：成员方法里的参数，例userName,born
　　　 2>实参：调用方法时传入的参数，例stuName,bornTime
　　　 注：形参和实参数据类型、数量都要一致
3、方法重载：方法名相同，参数列表不同（个数或类型不同），返回值类型和修饰符可以不同
　　public double result(double num1,double num2){
　　　　 return num1+num2;
　　 }
　　 public double result(double num1,double num2,double num3){
　　　　 return num1+num2+num3;
　　 }
4、构造方法
　 （1）访问修饰符 方法名(){}
　 （2）作用：进行数据初始化
　 （3）生成构造方法：右击generate(Alt+Insert)——>Constructor——>生成几个参数选几个
　 （4）注意：方法名必须与类名相同
　　　　　　　 系统默认分配的，没有返回值，当创建对象时会默认调用无参方法
　　　　　　　 如果手动编写了构造方法，那么系统便不再自动分配无参构造，需要手动添加
　　　　 public class Student {
　　　　　　 String name;
　　　　　　 String sex;
　　　　　　 int age;
　　　　　　 int id;
　　　　　　 public Student() {
　　　　　　 }
　　　　　　 public Student(int Id, String Name){
　　　　　　　　 this.id=Id;
　　　　　　　　 this.name=Name;
　　　　　　 }
　　　　　　 public Student(int Id,String Name,int Age,String Sex){
　　　　　　　　 this(Id,Name);
　　　　　　　　 this.age=Age;
　　　　　　　　 this.sex=Sex;
　　　　　　 }
　　　　　　public void show(){
　　　　　　　　System.out.println(this.id+this.name+this.age+this.sex);
　　　　　　 }
　　　　　　 public static void main(String[] args){
　　　　　　　　 Student stu1=new Student(1,“张三”,13,“男”);
　　　　　　　　 stu1.show();
　　　　　　}
　　　　 }
5、this的作用
　　 解决局部变量和成员变量冲突；指代当前对象，谁调用指的就是谁
　　 注：this只能调用实例变量、实例方法和构造方法，不能调用静态变量和静态方法，也不能调用局部变量；
6、包
　包的命名规范：域名.公司简称.功能名称
　　　　　　　　　 cn.jbit.login
　 声明包：package，声明当前类所在的包
　 导入包:import，在当前类中要使用到的其他类所在的包
7、封装
　 优点：隐藏类的状态信息和实现细节，让使用者只能通过程序规定的方法来访问数据；可以方便加入存取控制语句，限制不合理操作。
　 步骤：1、private属性私有化。 2、设置setter/getter方法。 3、设置属性的存取控制。
　　　　 public class Test{
　　　　　　　 private String name;
　　　　　　　 public String getName() {
　　　　　　　　　　 return name;
　　　　　　　 }
　　　　　　　 public void setName(String name) {
　　　　　　　　　　 this.name = name;
　　　　　　　 }
　　　　　}
8、static 静态
　 （1）静态变量（类变量）： 用static修饰的变量，通过类名.变量直接调用;任何方法中不能定义静态变量;它可以由这个类创建的所有对象共享；一般配合final使用，定义为静态常量；例：都是一个班级
　　　　 实例变量：不用static修饰，通过实例对象调用；
　　　　 public class Test{
　　　　　　　 static String name=“张三”;
　　　　　　　int age=15;
　　　　　　　public static void main(String[] args){
　　　　　　　　　　name=“李四”; //正确，静态变量中可直接使用
　　　　　　　　　　 age=16; //错误，必须实例化类才可以用
　　　　　　　　　　 System.out.println(Test.name);
　　　　　　　　　　 Test test=new Test();
　　　　　　　 　　　 System.out.println(test.age);
　　　　　　　 　　　 static int born; //错误，方法中不能定义静态变量
　　　　　　　 }
　　　　　 }
　 （2）静态方法（类方法）：用static修饰，通过类名.方法名调用；只能访问类属性和其他类方法,不能直接访问实例变量和实例方法；
　　　　实例方法：不用static修饰，通过实例对象调用；可直接访问所属类的静态变量、静态方法、实例变量和实例方法；
　 （3）静态块:不需要调用，并且只加载一次
　　　　 在加载类的过程，会先完成静态变量的内存分配，再执行静态块，这些都是创建对象前执行；
9、继承extends
　（1）优点：解决编程中代码冗余问题，是实现代码重用的一种重要手段之一
　 （2）特性:单根性 传递性
　 （3）子类可以继承父类的哪些财产：
　　　　 无法继承private修饰的属性和方法
　　　　 无法继承父类的构造方法，需要通过super
　　　　 继承默认修饰符修饰的属性和方法，但子父类必须在同一个包里
　　　　 继承public和protected修饰的属性和方法，无论子父类是否在同一个包里
　（4）this和super的异同点
　　　 1>不同
　　　　　 super:调用父类构造方法
　　　　　　　　 如果子类的构造方法没有通过super显式调用父类有参构造，也没有通过this调用本类其他构造，系统会默认调用父类无参。
　　　　　　　　 如果存在多继承关系，在创建一个子类对象时，以上规则会向更高一级父类传递，一直执行到顶级父类Object
　　　　　 this:调用本类其他构造方法
　　　 2>相同
　　　　 在构造方法中，this与super不能共存，并且super必须是第一句
　　　　 在实例方法中，不要求出现在第一句，可以共存
　　　　 在静态方法中，不允许出现super或this
　（5）重写：子父类的关系，方法名相同，参数列表相同，返回值类型相同
　　　　　　 子类访问修饰符权限大于等于父类
　　　　public class Father {
　　　　　　　 private String name;
　　　　　　　 public Father(){}
　　　　　　　 public Father(String name){this.name = name;}
　　　　　　　public String getName(){return name;}
　　　　　　　public void setName(String name){this.name = name;}
　　　　　　　protected void print(){}
　　　　}
　　　　 public class Son extends Father{
　　　　　　　 private int password;
　　　　　　　 public Son(){}
　　　　　　　 public Son(String name,int password){super(name);this.password = password;}
　　　　　　　public int getPassword(){return password;}
　　　　　　　 public void setPassword(int password){this.password = password;}
　　　　　　　public void print(){}
　　　　　}
10、多态
　（1）多态：继承是多态的基础，没有继承就没有多态。
　　　　　　 多态是具有表现多种形态的能力的特征。
　　　　　　　同一个接口，使用不同的实例而执行不同的操作，
　　　　　　　多态可以减少类中的代码量，也可以提高代码的可扩展性和可维护性。
　 （3）实现方式：父类作为形参 public String name(Father father){
　　　　　　　　　　　　　　　　　　 return father.getName();
　　　　　　　　　　　　　　　 }
　　　　　　　　　父类作为返回值 public Father name(){
　　　　　　　　　　　　　　　　　　　Father father=new Son();
　　　　　　　　　　　　　　　　　　　return father;
　　　　　　　　　　　　　　　　　 }
　 （2）向上转型：Father dog=new Son(“豆豆”,9);
　　　　向下转型：if(pet instanceof Dog) { //instanceof判断pet是否是Dog的实例
　　　　　　　　　　　　 Dog dog = (Dog) pet;
　　　　　　　　　　　　 dog.doWork();
　　　　　　　　　 }
11、面向对象三大特征
　　封装：保证对象自身数据的完整性和安全性
　　继承：建立类之间的关系，实现代码复用，方便系统扩展
　　多态：相同的方法调用，不同的实现方式
12、Object超级父类：是所有Java类的祖先类,在定义一个类时，如果没有继承，直接继承Object类
　　 equals（）方法重写
　　 public boolean equals(Object o){
　　　　　 if(this＝＝o){
　　　　　　　　 return true;
　　　　　　}
　　　　　 if(!(o instanceof Student)){
　　　　　　　　return false;
　　　　　}
　　　　　Student stu= (Student) o;
　　　　　 if(this.stuNo＝＝stu.stuNo &&this.name＝＝stu.name){
　　　　　　　　 return true;
　　　　　 }else{
　　　　　　　　return false;
　　　　　 }
　　 }
13、值传递与引用传递
　　 值传递：copy一份再修改
　　 引用传递：栈中地址指向同一个，修改同一个对象
14、抽象方法abstract
　　 定义：没有方法体的方法
　　 优点：抽象类中已经实现的方法可以被子类使用，使代码可以复用（主要作用），同时提供了抽象方法，保证了子类具有自身的独特性
　　 注：1>含有抽象方法的类必须定义为抽象类
　　　　 2>抽象类中可以有抽象方法，也可以有具体方法
　　　　 3>抽象类不能被实例化
　　　　　 public abstract class AbstFather {
　　　　　　　 public abstract void print();
　　　　　　　public void show(){}
　　　　　 }
　　　　 4>如果子类没有实现父类所有抽象方法，子类也必须定义为抽象类
　　　　　 public class Abst extends AbstFather{
　　　　　　　　public void print() {}
　　　　　 }或者
　　　　　 public abstract class Abst extends AbstFather{}
　　　　5>没有抽象构造方法，也没有抽象静态方法
15、接口interface
　　 注：1>接口中只能有抽象方法，一个功能指向的入口，是一种标准和规范；接口是一种特殊的抽象类，利于代码的扩展和维护。
　　　　　public interface InterImpl {
　　　　　　　　public static final int A=5;
　　　　　　　　 public abstract double internet(double inter);
　　　　　 }
　　　　2>接口中的成员变量默认都是public static final的静态常量；接口中的方法默认都是public abstract的抽象方法
　　　　　public interface InterImpl {
　　　　　　　　int A=5;
　　　　　　　　 double internet(double inter);
　　　　　　}
　　　　　3>接口中没有构造方法，不能被实例化
　　　　　4>一个接口可以继承多个接口，但接口不能继承类
　　　　　　public interface InterImpl extends MassageImpl,TalkImpl{}
　　　　　 5>接口的实现类必须实现接口的全部方法，否则必须定义为抽象类
　　　　　　 public class Ant implements InterImpl {
　　　　　　　　　public double internet(double inter) { return 0; }
　　　　　　 }
　　　　　6>类只能继承一个父类，但可以实现多个接口，必须实现接口的所有方法，否则必须定义为抽象类；
　　　　　　如果一个类继承父类的同时又实现了多个接口，extends位于implements之前
　　　　　　public interface MassageImpl {
　　　　　　　　　double talkTime(double talktimes);
　　　　　　　　　double massageNum(int num);
　　　　　　}
　　　　　　public class Tencent extends Cards implements MassageImpl,InterImpl {
　　　　　　　　　public double talkTime(double talktimes) { return 0; }
　　　　　　　　　public double massageNum(int num) { return 0; }
　　　　　　　　　 public double internet(double inter) { return 0; }
　　　　　　　}