7月9日 面向对象2

7月9日 面向对象2

1.包Package与导入import

1.包机制: 文件夹
    1) 便于管理众多的资源
    2) 提供了多重的命名空间

  命名规范:
    公司域名倒着写    com.xxxx.xxxx

 包信息存在与java文件的首行

2.导包 : 指明要使用的类的位置
    import 包名.类名;
    位置: 类对的上面,包信息的下面

    1)使用的时候指明类的权限定名,完整路径
        只能在当前只一次使用有效
    2)import 包名.类名;
    3)模糊匹配 *
        模糊匹配当前包下的所有类  import java.util.*;
        影响编译效率不会影响运行效率
    4)静态导入
        只能导入某个类中的静态内容

public class Class001_Package {
    public static void main(String[] args) {
        java.util.Scanner sc = new java.util.Scanner(System.in);
        Random ran = new Random();
        List list = new ArrayList();

        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);

        System.out.println(round(3.5));


    }
}


class Demo{}

2.私有类private关键词

类似年龄,可能存储负数,或者不符合业务逻辑要求的一些数据
程序可能存在安全隐患,
解决安全隐患: 介绍一个关键字 private 私有的

private 私有的 :
    成员修饰符,不能修饰局部
    成员只能在本类中使用

提供公共的访问方式:
    公共的成员方法(非静态)
    设置器 setter
    访问器 getter

私有的属性,配合公共的访问方式提供成员的安全性

面向对象的三大特性: 封装   继承   多态
    属性私有化配合公共的访问方式就是封装的具体体现
    方法,类..都是封装的体现
    私有是封装,封装不一定是私有

封装:
    隐藏内部的实现细节,对外提供公共的访问方式

封装的优点:
    1.提高安全性
    2.提高了复用性

注意: 未来所定义的javabean类,所有的属性都应私有化,并提供公共的访问方式

public class Class001_Person {
    public static void main(String[] args) {
        Person p = new Person();

        p.name = "zhangsan";
        //p.age = -18;
        p.setAge(20);
        p.show();

        System.out.println(p.getAge());

    }
}

class Person{
    public String name;
    //私有的属性
    private int age;

    public Person(){
    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //设置器
    //为私有的age属性赋值
    public void setAge(int age){
        if(age<0 || age>150){
            return;
        }
        this.age = age;
    }

    //访问器
    public int getAge(){
        return this.age;
    }


    public void show(){
        System.out.println(name+"-->"+age);
    }
}

3.用户测试类

public class Class002_User {
    public static void main(String[] args) {
        User user = new User();
        user.setId(101);
        user.setUsername("zhangsan");
        user.setPassword("lisi");
        user.show();
    }
}

class User{
    //属性私有化
    private int id;
    private String username;
    private String password;

    //构造器
    public User(){

    }

    public User(int id,String username,String password){
        this.username = username;
        this.id = id;
        this.password = password;
    }

    //公共的设置器与访问器
    public void setId(int id){
        this.id = id;
    }
    public void setUsername(String username){
        this.username = username;
    }
    public void setPassword(String password){
        this.password = password;
    }

    public int getId(){
        return id;
    }
    public String getUsername(){
        return username;
    }
    public String getPassword(){
        return password;
    }

    //功能
    public void show(){
        System.out.println(id+"-->"+username+"-->"+password);
    }
}

4.继承

继承 :
     子承父业

 作用: 子类一旦继承父类,就有权使用父类中的内容
       子类中可以扩展自己独有的内容  延续+扩展

 定义: 子类 extends 父类

 为什么要定义继承: 为了提高代码的复用性

 父类 | 基类 | 超类 : 被继承的类
 子类 | 派生类 : 继承父类的类

 特点:
     java中的继承是单继承机制
         优点: 简单
         缺点: 不变与后期维护,不够灵活

     一个子类只能存在一个直接父类
     一个父类可以存在多个子类

 面向对象的设计原则之一:
     开闭原则 : 对修改关闭,对扩展开放


 javabean : 抽取一系列对象的共性
 父类: 子类的共性

 要求:
     1.定义猫类,定义狗类,-->父类,测试继承的使用特点

public class Class001_Extends {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();

        teacher.name = "马云";
        teacher.age = 30;
        teacher.subject = "英语";

        teacher.teach();
        teacher.sleep();

        teacher.show();
    }
}

//父类
class Person{
    public String  name;
    public int age;

    public void sleep(){
        System.out.println("休息");
    }
}

//教师类
class Teacher extends Person{
    public String subject; //教授学科

    public Teacher(){}

    public void teach(){
        System.out.println("教书育人");
    }

    public void show(){
        System.out.println(name+"-->"+age+"-->"+subject);
    }
}

//学生类
class Student extends Person{
    public int id; //学号

    public Student(){}

    public void study(){
        System.out.println("学习...");
    }

}

5.super

super 与  this 之间的区别:
    this  指代当前对象
    super 指代父类对象

先静态后成员
在子父类关系下,创建子类对象 : 先父类后子类 (在子类内存空间中存储父类对象,可以通过super在子类中使用父类对象)
super需要在子类中使用

1.在子类的构造器首行通过super调用父类的执行构造器
    super(参数列表)
    默认在子类构造器的首行会调用父类的空构造 super()
    在子类构造器的首行不能同时显示存在this()与super(),因为都需要定义在首行第一个条语句

2. super区分子父类中同名成员问题
    如果子父类中出现同名的成员,子类中使用这个成员,默认就近原则
    如果想要调用父类同名成员,通过super.调用父类成员 (super指代子类内存中的父类对象)
    this用来区分局部与成员之间同名问题
        默认就近原则找局部
        可以通过this.调用本类成员
        可以通过super.调用父类成员
    如果不存在同名问题,指代父类成员可以省略super.
    如果不存在同名问题,知道子类成员可以省略this.

public class Class002_Super {
    public static void main(String[] args) {
        Apple f = new Apple("红富士");
        f.show();
    }
}

//父类
class Fruit{
    public String type;
    public String color;
    public String haha = "父类哈哈";

    public Fruit(){
        System.out.println("父类构造器");
    }

    public Fruit(String type){
        System.out.println("父类带参造器");
        this.type = type;
    }
}

//子类
class Apple extends Fruit{
    public String haha = "子类哈哈";

    public Apple(){
        //super();
        System.out.println("子类构造器");
    }

    public Apple(String type){
        super(type);
        System.out.println("子类带参构造");
    }

    public void show(){
        System.out.println(super.type+"-->"+color);

        //局部变量
        String haha = "局部哈哈";
        System.out.println(haha); //局部
        System.out.println(this.haha); //本类成员
        System.out.println(super.haha); //父类成员
    }
}

父类带参造器
子类带参构造
红富士–>null
局部哈哈
子类哈哈
父类哈哈

6.Override

        重写 Override:  ****
    简单题: 重写与重载之间的区别
        都是方法的一种特性
        重载:
            1.同一个类中的多个方法
            2.方法名相同
            3.参数列表不同|方法签名不同

        重写:
            1.不同的两个类
            2.继承|实现关系
            3.方法签名相同


        使用前重写的前提需求 : 子类对父类某个 功能满意,功能实现不满意,可以在子类中对这个功能进行重新实现-->重写

        使用特点: 子类引用会调用子类中重写的方法,子类没有找父类,子类有找子类,会对父类中的方法进行屏蔽

        如何检查一个方法是否是重写方法:
            1.在行号的后面显示,点击会跳转到对应被重写的方法位置
            2.@Override 强制检查一个方法是否为重写方法


        详细要求:
            == 方法签名
            <= 返回值类型 :
                基本数据类型 : 完全相等
                引用数据类型 : 子类中重写方法的返回值类型 <= 父类中被重写方法的返回值类型
                没有返回值类型 : 完全相等
            >= 权限修饰符 :
                子类中重写方法的权限修饰符 >= 父类中被重写方法的权限修饰符

        不能被重写的方法:
            1.被private修饰的方法不能被重写
            2.被final修饰的方法不能被重写
            3.被static修饰的方法不能被重写
                子类中如果存在与父类静态方法同名的方法,要求子类中的同名方法也需要被static修饰

public class Class002_Super {
    public static void main(String[] args) {
        Apple f = new Apple("红富士");
        f.show();
    }
}

//父类
class Fruit{
    public String type;
    public String color;
    public String haha = "父类哈哈";

    public Fruit(){
        System.out.println("父类构造器");
    }

    public Fruit(String type){
        System.out.println("父类带参造器");
        this.type = type;
    }
}

//子类
class Apple extends Fruit{
    public String haha = "子类哈哈";

    public Apple(){
        //super();
        System.out.println("子类构造器");
    }

    public Apple(String type){
        super(type);
        System.out.println("子类带参构造");
    }

    public void show(){
        System.out.println(super.type+"-->"+color);

        //局部变量
        String haha = "局部哈哈";
        System.out.println(haha); //局部
        System.out.println(this.haha); //本类成员
        System.out.println(super.haha); //父类成员
    }
}

public class Class001_Override {
    public static void main(String[] args) {
        SiCong cong = new SiCong();
        cong.words();
    }
}

class JianLin{
    public String name = "王健林";

    JianLin words(){
        System.out.println("先定一个小目标,挣它一个亿...");
        return null;
    }
}

class SiCong extends JianLin{
    public String name = "王思聪";

    //重写方法
    @Override
    public JianLin words(){
        System.out.println("我不在乎我的朋友有钱没钱,反正没我有钱...");
        return null;
    }
}

7.final

final关键字
    最终的
    final可以修饰成员可以修饰局部

    1.被fianl修饰的变量为常量
    2.被final修饰的方法不能被重写
    3.被final修饰的类不能被继承-->太监类

public class Class001_Final {
    static final Num  N = new Num();

    public static void main(String[] args) {
        //引用n指向一个新的对象
        //N = new Num();
        //修改对象的成员,但是指向的对象没变
        N.num--;

    }
}

class Num{
    int num = 100;
}

8.object

Object 类
    老祖宗类
    是java中所有类的父类
    java中的类都会直接或者间接的继承自Object类
    如果一个类没有显示的继承自其他类,默认继承自Object类

toString()  把对象数据转为字符串的表现形式
    如果直接打印一个引用,默认打印的是这个调用toString方法的返回值
    需求: 以一个字符串展示一个对象,想要了解到对象的一些基本的信息(成员变量的值)
    Object类中的toString方法的实现: 默认以对象的地址展示
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
    子类中重写toString方法,实现返回对象的成员变量的值非地址值



equals 比较两个对象是否相等
    Object 类中equals默认比较 : 对象的地址
                            public boolean equals(Object obj) {
                                return (this == obj);
                            }
    如果不想比较对象的地址,想要比较所有成员变量的值,可以在子类中重写equals方法

equals与==之间的区别:
    == : 基本数据类型比较数据值
         引用数据类型比较对象的地址值'

    equals : 只能比较引用数据类型
            默认比较对象的地址
            可以通过重写实现比较对象内容(成员变量的值)

 注意: 以后要在javabean类中重写toString()与equals()方法

public class Class001_Object01{
    public static void main(String[] args) {
        //toString
        Person p = new Person();
        p.name = "zhangsan";
        p.age = 19;
        System.out.println(p.toString());
        System.out.println(p);

        Person p2 = new Person(); //0x001
        p2.name = "zhangsan";
        p2.age = 19;

        //比较两个person对象,不想比较地址,想要比较姓名
        System.out.println(p.equals(p2)); //0x001
        System.out.println(p==p2);

        //课后: 实现比较对象的所有成员变量的值

    }
}

class Person{
    public String name;
    public int age;

    public Person(){}


    public void show(){
        System.out.println(name+"-->"+age);
    }

    //重写方法
    @Override
    public String toString() {
        return name+","+age;
    }

    //比较两个person对象,不想比较地址,想要比较人的姓名,姓名相等就像等
    @Override
    public boolean equals(Object obj) {  //Object obj = 0x001;
        //增强程序健壮性
        if(this == obj){
            return true;
        }

        //判断obj指向的是一个Person对象么??
        if(obj instanceof Person){
            //如果是就把obj从Object转为Person类型
            Person p = (Person)obj;  //Person p = 0x001;
            //可以调用Person类中的成员
            String name2 = p.name;
            String name1 = this.name;
            return name1.equals(name2);
        }
      return false;
    }
}

zhangsan,19
zhangsan,19
true
false

9.封装

 访问权限修饰符:
        成员的被访问权限
        成员修饰符,不能修饰局部

                            本类                  同包类                 不同包下的子类                 不同包下的其他类
 公共的   public              √                       √                       √                               √
受保护的 protected           √                       √                       √
  默认的  default             √                       √
 私有的  private             √

        能够修饰的类的 : public , default(省略)
        私有的内容能被继承,但是无权使用
        受保护的成员 :
                    1.同包类
                    2.在不同包的子类中,通过继承关系访问
        常用的权限修饰符:
                        public
                        private

public class Class001_Modifier {
    public String testPublic = "public";
    protected String testProtected = "protected";
    String testDefault = "default";
    private String testPrivate = "private";

    public static void main(String[] args) {
        Class001_Modifier cm = new Class001_Modifier();
        System.out.println(cm.testDefault);
        System.out.println(cm.testPrivate);
        System.out.println(cm.testProtected);
        System.out.println(cm.testPublic);
    }

    public void test(){
        System.out.println(testDefault);
        System.out.println(testPrivate);
        System.out.println(testProtected);
        System.out.println(testPublic);
    }
}

//同包类
class Demo {
    public static void main(String[] args) {
        Class001_Modifier cm = new Class001_Modifier();
        System.out.println(cm.testDefault);
       //System.out.println(cm.testPrivate);
        System.out.println(cm.testProtected);
        System.out.println(cm.testPublic);
    }
}

import com.yjx.modifier04.Class001_Modifier;

/*
    不同包下的子类
        测试: 测试通过继承关系在子类中使用父类中受保护的成员
 */
public class Class002_Son extends Class001_Modifier{
    public static void main(String[] args) {
        //通过父类对象无法访问父类中受保护的成员  : 在子类中,但不是通过继承关系
        Class001_Modifier cm = new Class001_Modifier();
        //System.out.println(cm.testProtected);
        System.out.println(cm.testPublic);

        //1)在子类中使用  2)通过继承关系使用
        Class002_Son  son = new Class002_Son();
        System.out.println(son.testProtected);
        System.out.println(son.testPublic);
    }

    public void test(){
        //System.out.println(testDefault);
        //System.out.println(testPrivate);
        System.out.println(testProtected);
        System.out.println(testPublic);
    }
}

import com.yjx.modifier04.Class001_Modifier;

/*
    不同包下的其他类
 */
public class Class001_Other {
    public static void main(String[] args) {
        Class001_Modifier cm = new Class001_Modifier();
        //System.out.println(cm.testDefault);
        //System.out.println(cm.testPrivate);
        //System.out.println(cm.testProtected);
        System.out.println(cm.testPublic);
        //1)通过继承关系  2)不是在子类中使用
        Class002_Son  son = new Class002_Son();
        //System.out.println(son.testProtected);
        System.out.println(son.testPublic);
    }
}

10.Javabean

JavaBean 定义规范:
    1.类是公共的
    2.至少提供一个构造器
    3.私有的属性
    4.公共的访问方式

public class Class001_Javabean {
}

class User{}