java面向对象（三）

1、四种权限修饰符

public > protected > (default) > private
注意：（default）并不是关键字default,而是根本不写

代码示例

package day06;

import day06.sub.MyClass;

public class DemoMain {
    public static void main(String[] args) {
        //同一个包中私有类的私有变量不能被访问
        System.out.println(new Self().name);
        System.out.println(new Self().job);
        System.out.println(new Self().money);
        //System.out.println(new Self().age);错误：private只能在本类中访问

    }
}

package day06;

public class Self {
    public String name="史强";
    protected String job="警察";
    int money=30000;
    private int age=18;

    public static void main(String[] args) {
        //本类中都可以访问；
        // 注意静态方法（static）中不能使用this
        System.out.println(new Self().name);
        System.out.println(new Self().job);
        System.out.println(new Self().money);
        System.out.println(new Self().age);
    }
}

package day06.sub;

//即使在子包下，但是没有在同一个包里面，就必须要进行导包设置；
import day06.Self;

public class MyClass extends Self {
    /*不同包下的子类，只有public和protrcted可以访问*/
    String job=super.job;
    String name=super.name;
    //int age =super.age;//报错，权限不够，不能访问
    //int money=super.money;//报错，权限不够，不能访问
    public void show(){
        System.out.println(job);
        System.out.println(name);
    }

    public static void main(String[] args) {
        MyClass nn=new MyClass();
        nn.show();
    }
}

package day06.sub;

import day06.Self;

public class Other {
    /*不在同一个包下，也不是子类*/
    public static void main(String[] args) {
        System.out.println(new Self().name);
        //只有public修饰的name不报错，其他的权限都不够
//        System.out.println(new Self().job);
//        System.out.println(new Self().money);
//        System.out.println(new Self().age);
    }
}

2、java包机制

2.1 Packeage包

package包对应系统的文件夹；
- 防止命名冲突造成使用不便；
- 格式：公司域名+功能名|模块名

//写在类的第一行，可以写在注释后面，因为注释不编译；但是前面不能写任何代码;
package pkg1.[pkg2[pkg3...]]

注意：
- 不要定义与jdk相同的包，相同的类，否则会引起很多问题
- 写项目都需要加包，不要使用默认包
- com.opp和com.opp.test，这两个包没有包含关系，是两个完全独立的包，只是逻辑上看起来前者是后者的一部分；

2.2 import 导包

不需要导包的类
- 同一个包下的类；
- java.lang包下的类不需要导入；例如：String、
JDK中常用的包介绍
导包的方式
- 权限定名（指明完整路径）
```
//例如
void main(
    //只在当前处有效，每次使用都需要指明，繁琐；
	java.util.Scanner sc = new java.util.Scanner(System.in);
)
```
- import导入
  
  位置在类的上面
  
  方式:import 包名+类名
- 批量导入
  
  格式：import 包名.*;
  
  这样的导入方式，会使得编译效率降低；
- 静态导入
  
  格式：import static 包.类.静态变量|静态方法
  
  例如：import static Math.PI;

3、Object类

Java.lang.Object类是所有类的父类，（根类）；如果一个类没有父类默认继承Object类；

3.1 toString()方法

看一个类是否重写了toString方法，直接打印类对应的对象；如果不是地址值，则说明toString方法已经被重写了；

代码示例

package day06;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package day06;

public class DemoMainto {
    public static void main(String[] args) {
        Person p = new Person("张三",19);
        System.out.println(p);//直接打印对象名就是执行对象的toString()方法
        System.out.println(p.toString());//每个类都默认继承了Object的toString()方法
        //重写前的结果
        /*
        day06.Person@1540e19d
        day06.Person@1540e19d
        * */
        //重写后的结果
        //Person{name='张三', age=19}
        //Person{name='张三', age=19}
        
    }
}

3.2 equals方法

boolean equals(Object obj)
基本数据类型比较的是内容；引用类型比较的是地址值；
重写equals方法
快速生成equal+hashcode

String类中重写的equals方法

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

3.3 Objects

在java.utils.Objects中
Objects可以避免空指针异常

代码示例

package day06;

import java.util.Objects;

public class DemoMainto {
    public static void main(String[] args) {
        Person p = new Person("张三",19);
        System.out.println(p);//直接打印对象名就是执行对象的toString()方法
        System.out.println(p.toString());//每个类都默认继承了Object的toString()方法
        //重写前的结果
        /*
        day06.Person@1540e19d
        day06.Person@1540e19d
        * */
        //重写后的结果
        //Person{name='张三', age=19}
        //Person{name='张三', age=19}
        /*************************************/
        //Object.equals方法对两个对象进行比较，防止空指针异常;
        System.out.println("**********************************************************");
        String s1=null;
        String s2="AAA";
        //boolean b =s1.equals(s2);
        //注：String中equals方法重写了Object的方法;比较的是字符串的内容；字符串(引用类型)也可以用”==“判断地址值是否相等;
        //System.out.println(b);//NullPointerException,空指针异常；
        //使用Objects避免空指针；
        boolean cb= Objects.equals(s1,s2);
        System.out.println(cb);//false
    }
}

4、内部类

如果一个事务的内部包含另一个事务，那么这就是一个类内部包含另一个类。

例如：人体和心脏的关系；
分类
- 成员内部类
- 局部内部类（包含匿名内部类）

4.1成员内部类

定义

//格式
修饰符 class 外部类{
    修饰符 class 内部类{
        
    }
}

注意：内用外随意访问，外用内，需要内部类对象；
- 注：内部类编译之后以$符连接出现在文件中，因此类名称经常以下划线做分割，而非$符；
使用
- 间接方式：在外部类调用内部类的方法，main方法调用外部类
- 直接方式：
```
//语法
外部类名称.内部类名称 对象名=new 外部类名称().new 内部类名称();
```
访问外部类成员变量时遇见同名效果，使用外部类.this.变量

代码示例

package day06;

public class Body {//外部类

    public class Heart{//成员内部类
        String name="比尔·希恩斯";
        public void beat(){
            System.out.println("心砰砰砰的跳啊");
            System.out.println("我可以使用外部类的name"+name);
        }
        public void showname(){
            String name="章北海";
            System.out.println(name);//内部方法的局部变量；
            System.out.println(this.name);//内部类的成员变量
            System.out.println(Body.this.name);//外部类的成员变量
            //访问外部类成员变量时遇见同名效果，使用外部类.this.变量
        }
    }

    private String name;

    public Body() {
    }

    public Body(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("外部类的方法");
        new Heart().beat();//       调用成员内部类，供主方法间接使用
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package day06;

public class DemoMainClass {
    public static void main(String[] args) {
        Body body =new Body("张三");
        body.show();
        System.out.println("==========================");
        //直接调用的语法格式；
        Body.Heart obj=new Body("曼努尔·雷迪亚兹").new Heart();
        obj.beat();
        System.out.println("==============================");
        obj.showname();
    }
}
/*
外部类的方法
心砰砰砰的跳啊
我可以使用外部类的name比尔·希恩斯
==========================
心砰砰砰的跳啊
我可以使用外部类的name比尔·希恩斯
==============================
章北海
比尔·希恩斯
曼努尔·雷迪亚兹
*/

4.2局部内部类

定义

一个类定义到方法的内部，那么这就是一个局部类

局部：只有当前所属的方法才能使用他，出了这个方法外面就不能用了；

格式

类{
    方法{
        class 名称{//注意，这里class前面不能写权限修饰符；
            
        }
    }
}

补充
- 权限修饰符
  
  public > protected >(default) >private
- 定义一个类的时候，权限修饰符的规则
  
  1、外部类 public / default
  
  2、成员内部类 public / protected /(default) /private
  
  3、局部内部类：什么都不写
访问变量
- 局部内部类希望访问所在方发的局部变量，那么这个局部变量，必须是有小的final，因为局部变量在栈内存中，new出来的对象在堆内存中；

代码示例

package day06;

public class Outer {
    public void func(){
        class Inner{
            int num=10;
            public void show(){
                System.out.println(num);
            }
        }
        Inner obj= new Inner();
        obj.show();
    }
}


package day06;

public class Demo {
    public static void main(String[] args) {
        Outer oo=new Outer();
        oo.func();
    }
}

/*
10
*/

4.2 匿名内部类（*）

定义
- 如果接口的实现类（或者是父类的子类），只需要使用唯一的一次，
  
  那么这种情况下就可以省略掉该类的定义，而改为使用匿名内部类
- 格式
```
接口名称 对象名 = new 接口名称(){
  //覆盖重写所有抽象方法;  
};
```

代码示例

package day06;

public interface MyInterface {
    void show();//匿名方法，可以省略不写public abstract
}

package day06;

public class Demolambda  {
    public static void main(String[] args) {
        //接口的实现类需要implements来继承
        //使用匿名类进行实现接口;
        MyInterface objA= new MyInterface() {
            @Override
            public void show() {
                System.out.println("我重写了接口的方法");
            }
        };
        objA.show();
        //objA.show();一般只写一次，只使用一次，多次使用未见报错
    }
}

注意事项
- new代表创建对象的动作；
- 接口名称就是匿名内部类需要实现那个接口；
- {....},匿名内部类的内容
- 匿名内部类在创建对象的时候，只能使用唯一的一次；如果希望对此创建对象，而且类的内容一样的话，那么就必须使用淡定定义的实现类了
- 匿名对象在调用方法的时候只能使用唯一一次。如果希望同一个对象调用多次方法，那么必须给对象起个名字；例如上面的objA
- 匿名内部类是省略了实现类/子类名称，但是匿名对象对象省略了对象名称，匿名内部类和匿名对象不是一回事；

代码示例

package day06;

public class Demolambda  {
    public static void main(String[] args) {
        //接口的实现类需要implements来继承
        //此处使用的是匿名内部类，但是不是匿名对象，对象名是objA;
        MyInterface objA= new MyInterface() {
            @Override
            public void show() {
                System.out.println("我重写了接口的方法");
            }
        };
        objA.show();
        System.out.println("===========");
        //匿名对象
        new MyInterface() {
            @Override
            public void show() {
                System.out.println("匿名对象调用唯一一次的方法");
            }
        }.show();
    }
}
/*
我重写了接口的方法
===========
匿名对象调用唯一一次的方法
*/

5、类作为成员变量

代码示例

package day06;

public class Hero {
    private String name;
    private int age;
    //使用类作为成员变量
    private Weapon weapon;

    public Hero() {
    }

    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }
    public void attck(){
        System.out.println(name+"用"+weapon.getCode()+"攻击老航天");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

package day06;

public class Weapon {
    private String code;

    public Weapon() {
    }

    public Weapon(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

package day06;

public class DemoMainRun {
    public static void main(String[] args) {
        Hero hero =new Hero();
        hero.setName("章北海");
        hero.setAge(35);
        Weapon weapon =new Weapon("陨石子弹");
        hero.setWeapon(weapon);
        hero.attck();
    }
}
//章北海用陨石子弹攻击老航天

6、接口作为成员变量

代码示例

package day06;

public interface Skill {
    void use();
}


package day06;

public class SkillImpl implements Skill{
    @Override
    public void use() {
        System.out.println("同过实现类，使用了技能");
    }
}

package day06;

public class Hero {
    private String name;
    private int age;
    //使用类作为成员变量
    private Weapon weapon;
    private Skill skill;

    public Hero() {
    }

    public Hero(String name, int age, Weapon weapon,Skill skill) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
        this.skill=skill;
    }
    public void attck(){
        System.out.println(name+"用"+weapon.getCode()+"攻击老航天");
    }
    public void attcks(){
        skill.use();
    }

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

package day06;

public class DemoMainRun {
    public static void main(String[] args) {
        Hero hero =new Hero();
        hero.setName("章北海");
        hero.setAge(35);
        Weapon weapon =new Weapon("陨石子弹");
        hero.setWeapon(weapon);
        hero.attck();
        System.out.println("===================");
        //写法一,实现类
        SkillImpl skill=new SkillImpl();
        hero.setSkill(skill);
        hero.attcks();
        //写法二,匿名类
        Skill skillIn=new Skill() {
            @Override
            public void use() {
                System.out.println("通过匿名类实现了调用");
            }
        };
        hero.setSkill(skillIn);
        hero.attcks();
        //写发三，匿名对象
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("使用的匿名对象");
            }
        });
        hero.attcks();

    }
}
/*
章北海用陨石子弹攻击老航天
===================
同过实现类，使用了技能
通过匿名类实现了调用
使用的匿名对象
*/

7 补充：接口做参数返回值

package day06;

import java.util.ArrayList;
import java.util.List;

public class DemoIn {
    public static void main(String[] args) {
        //多态写法
        //左边是接口名称，右边是实现类;
        List<String> list =new ArrayList<>();
        List<String> result=addList(list);
        System.out.println(result);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }
    //接口作为参数和返回值
    public static List<String> addList(List<String> list){
        list.add("章北海");
        list.add("东方延续");
        list.add("褚岩");
        return list;
    }
}

/*
[章北海, 东方延续, 褚岩]
章北海
东方延续
褚岩
*/

posted @ 2021-11-09 11:14 紫青宝剑阅读(34) 评论(0) 编辑收藏举报

刷新页面返回顶部

紫青宝剑

java面向对象（三）

java面向对象（三）

1、四种权限修饰符

代码示例

2、java包机制

2.1 Packeage包

2.2 import 导包

不需要导包的类

JDK中常用的包介绍

导包的方式

3、Object类

3.1 toString()方法

3.2 equals方法

重写equals方法

3.3 Objects

4、内部类

4.1成员内部类

定义

使用

4.2局部内部类

定义

补充

访问变量

代码示例

4.2 匿名内部类（*）

定义

注意事项

代码示例

5、类作为成员变量

代码示例

6、接口作为成员变量

7 补充：接口做参数返回值

公告