Java基础(3)-面向对象

写于2019.5.16

参考：java1234

以对象的思维去分析和解决问题

访问控制权限、package、import

1. 访问权限

权限修饰词	类内	包内	子类	全局
Private	Yes	No	No	No
Package	Yes	Yes	No	No
Pretected	Yes	Yes	Yes	No
Public	Yes	Yes	Yes	Yes

注：Package为缺省的访问权限

1. package

• 用来归纳分类
• 便于项目开发维护
• 例子：com.java1234.chap01.sec05

1. import
   导入包

内部类和代码块

1. 内部类

• 在类的内部定义的类
• 可以方便的使用外部类的属性
• 破坏了类的基本结构
• 使用内部类：

/**
 * 外部类
 */
public class Outer {

    private int a=1;
    /**
     * 内部类
     */
    class Inner {
        public void show(){
            System.out.println("调用内部类的show");
            System.out.println(a);
        }
    }

    public void show() {

        Inner inner = new Inner();
        System.out.println("调用外部类的show");
        inner.show();
    }

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

输出

调用外部类的show
调用内部类的show
1

1. 代码块

• 普通代码块：写在方法里面

public class Demo01 {
    public static void main(String[] args) {
        int a =1;
        {
            a=2;
            System.out.println("普通代码块");
        }
        System.out.println("a="+a);

    }
}

• 构造代码块
  • 每次使用new实例化对象时都执行一次
  • 形式：{}
• 静态代码块
  • 只在第一次使用类，由JVM加载类时执行一次
  • 形式：static {}

  public class Demo02 {
    /**
     * 构造块:只执行一次，在加载类的时候执行
     */
    {
        System.out.println("通用构造块");
    }
  
    /**
     * 静态代码块:对象初始化的时候执行
     */
    static{
        System.out.println("静态代码块");
    }
    public Demo02(){
        System.out.println("构造方法一");
    }
  
    public Demo02(int i){
        System.out.println("构造方法二");
    }
  
    public Demo02(int i, int j){
        System.out.println("构造方法三");
    }
  
    public static void main(String[] args) {
        Demo02 demo02_1 = new Demo02();
        Demo02 demo02_2 = new Demo02(1);
        Demo02 demo02_3 = new Demo02(1,2);
    }
  }

  输出

  静态代码块
  通用构造块
  构造方法一
  通用构造块
  构造方法二
  通用构造块
  构造方法三

  String类

1. 两种比较

形式	功能
==	比较引用的位置是否相同
equals()	比较各自引用对象的内容

public class Demo01 {
    public static void main(String[] args) {
        String name1 = "张三";
        String name2 = new String("张三");
        String name3 = name2; // 传递引用

        // 比较引用
        System.out.println("name1==name2 " + (name1==name2));
        System.out.println("name1==name3 " + (name1==name3));
        System.out.println("name2==name3 " + (name2==name3));

        // equals比较内容
        System.out.println("name1.equals(name2) " + name1.equals(name2));
        System.out.println("name1.equals(name3) " + name1.equals(name3));
        System.out.println("name2.equals(name3) " + name2.equals(name3));
    }
}

输出

name1==name2 false
name1==name3 false
name2==name3 true
name1.equals(name2) true
name1.equals(name3) true
name2.equals(name3) true

1. 两种实例化方法的区别

• String name1="张三"：如果字符串常量池中已存在"张三"，则直接引用；否则创建新的字符串
• String name1=new String("张三")：无论字符串是否存在，都创建新的字符串

public class Demo02 {
    public static void main(String[] args) {
        String name1 = "张三";
        String name2 = "张三";

        String name3 = new String("张三");
        String name4 = new String("张三");

        System.out.println("name1==name2 "+(name1==name2));
        System.out.println("name1==name3 "+(name1==name3));
        System.out.println("name3==name4 "+(name3==name4));
    }
}

输出

name1==name2 true
name1==name3 false
name3==name4 false

1. String的内容不可修改

2. 常用方法

方法	描述
charAt()	返回指定索引位置的字符
length()	返回字符串长度
indexOf()	返回与指定字符匹配的第一个字符索引
subString()	返回指定索引范围内的字符构成的字符串
toUpperCase()	将字符串中的小写字母转成大写
toLowerCase	将字符串中的大写字母转成小写
trim()	去除字符串首尾的空格

具体参考：JDK_API_1_6_zh_CN

扫描二维码关注公众号，回复： 6249951 查看本文章

public class Demo04 {
    public static void main(String[] args) {
        String name = "张三";
        char ming = name.charAt(1);
        System.out.println(ming);

        String str = "我是中国人";
        for(int i=0; i<str.length(); i++){
            System.out.println(str.charAt(i));
        }
    }
}

public class Demo05 {
    public static void main(String[] args) {
        String str = "sgadhakjkdjalddass";
        System.out.println("d在字符串str中第一次出现的索引位置是"+str.indexOf('d'));
        System.out.println("d在字符串str中第一次出现的索引位置，从索引5位置开始 "+str.indexOf('d',5));
    }
}

public class Demo06 {
    public static void main(String[] args) {
        String str = "不开心每一天";
        String str2 = "不开心每一天不可能";
        System.out.println(str.substring(1));
        System.out.println(str.substring(1,6));

    }
}

public class Demo07 {
    public static void main(String[] args) {
        String str = "I'm a boy!";
        System.out.println(str.toUpperCase());
        System.out.println(str.toLowerCase());
    }
}

public class Demo08 {
    public static void main(String[] args) {
        String str = "  aB232 23 & &*( s2 ";
        // 去掉前后空格
        String newStr = str.trim();
        System.out.println("原始字符串："+str);
        System.out.println("去掉前后空格："+newStr);
        int letterCount = 0;
        int spaceCount = 0;
        int digitCount = 0;
        int otherCount = 0;
        for(int i=0; i<newStr.length(); i++){
            char c = newStr.charAt(i);
            if(c>='a' && c<='z' || c>='A' && c<='Z')
                letterCount++;
            else if(c==' ')
                spaceCount++;
            else  if(c>='0' && c<='9')
                digitCount++;
            else
                otherCount++;
        }
        System.out.println("英文字符数："+letterCount);
        System.out.println("空格字符数："+spaceCount);
        System.out.println("数字字符数："+digitCount);
        System.out.println("其它字符数："+otherCount);
    }
}

继承

• java只能单继承
• 私有方法不能继承
• 对象实例化过程和super关键字
  • super：调用父类的属性或方法，super()

final关键字和抽象类

1. final

• 终结，完结

用法	描述
final修饰类名	该类不可被继承
final修饰方法	该方法不可被重写
final修饰变量	该变量内容初始化后不可被修改，作为常量使用

/**
 * 僵尸类
 */
public final class Jiangshi {

}

public class People {
    private final int a=1;
    public void action() {
        System.out.println("做一个良好的公民");
    }
}

1. 抽象类

• 含有一个抽象方法的类称为抽象类
• 至少含有一个抽象方法
• 抽象类和抽象方法都需要使用abstract关键字修饰
• 抽象类必须被子类（普通类）重写抽象方法
• 抽象类不能被实例化

public abstract class People {
    private String name;

    public String getName() {
        return name;
    }

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

    public void say() {
        System.out.println("我的名字叫"+name);
    }

    public abstract void profession();
}

public class Teacher extends People {
    @Override
    public void profession() {
        System.out.println("我的职业是老师");
    }
}

public class Student extends People {
    @Override
    public void profession() {
        System.out.println("我的职业是学生");
    }
}

public class Test {
    public static void main(String[] args) {
//        People people = new People(); // 报错，抽象类不能被实例化
        Student student = new Student();
        Teacher teacher = new Teacher();
        student.profession();
        teacher.profession();
    }
}

接口

• 没有普通方法。与抽象方法和全局常量组成
• 接口必须被实现
• 一个类可以实现多个接口
• 同时继承类和实现接口：先继承类，后实现接口

public interface A {
    /**
     * 全局常量
     */
    public static final String TITLE = "www.java1234.com";

    /**
     * 抽象方法：abstarct可以省略
     */
    public void a();
}

public interface B {
    /**
     * 全局常量
     */
    public static final String TITLE2 = "Java知识分享网";

    /**
     * 抽象方法：abstarct可以省略
     */
    public void b();
}

public class C {
    public void c() {
        System.out.println("c方法");
    }
}

public class Test extends C implements A,B { // 必须先继承，后实现接口
    @Override
    public void a() {
        System.out.println("a方法");
    }

    @Override
    public void b() {
        System.out.println("b方法");
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.a();
        test.b();
        System.out.println(Test.TITLE);
        System.out.println(Test.TITLE2);
    }
}

输出

a方法
b方法
www.java1234.com
Java知识分享网

多态性

• 表现
  • 方法的重载与重写
  • 可以用父类指向子类的具体实现，调用方法时，如果子类中重载或重写了该方法，则自动调用子类的方法，否则调用父类方法；
  • 父类随时可以归还为其它子类的具体实现

  public class Animal {
    public void say() {
        System.out.println("我是一个动物");
    }
  }

  public class Dog extends Animal{
    @Override
    public void say() {
        System.out.println("我是一只狗");
    }
  }

  public class Cat extends Animal {
    @Override
    public void say() {
        System.out.println("我是一只猫");
    }
  }

  public class Test {
    public static void main(String[] args) {
        // 父类引用指向Dog子类的具体实现
        Animal animal = new Dog();
        animal.say();
  
        // 随时更换实现
        /*animal = new Cat();
        animal.say();*/
  
        Dog dog = (Dog)animal;
        dog.say();
  
        /*Cat cat = (Cat)animal; // 运行抛出异常
        cat.say();*/
    }
  }

• 转型
  • 向上转型：子类类型转到父类，安全
  • 向下转型：父类类型转到子类，不安全，可能抛出运行异常

public interface People {
    public void say();
}

public class Student implements People{
    @Override
    public void say() {
        System.out.println("我是学生");
    }
}

public class Teacher implements People {
    @Override
    public void say() {
        System.out.println("我是老师");
    }
}

public class Test2 {
    public static void main(String[] args) {
        People p1 = new Student();
        p1.say();

        p1 = new Teacher();
        p1.say();

        Student student = (Student) p1; // 运行抛出异常
        student.say();
    }
}

Object类

• 所有的Java类都继承自Object类
• toString()
• equals()

public class People {
    private String name;

    public People(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return this.name;
    }

    @Override
    public boolean equals(Object obj) {
        String name=((People)obj).getName();
        return this.name.equals(name);
    }

    public static void main(String[] args) {
        People p1 = new People("张三");
        People p2 = new People("李四");
        System.out.println(p1);
        System.out.println(p1.toString());

        People p3 = new People(new String("李四"));
        System.out.println(p1.equals(p2));
        System.out.println(p2.equals(p3));
    }
}

输出

张三
张三
false
true

instancesof关键字

• 判断一个对象是否属于一个类
• 形式：对象 instancesof 类型， 返回boolean类型
• 可以用于向下转型时判断对象类型

public class Animal {
    public void say(){
        System.out.println("我是一个动物");
    }
}

public class Dog extends Animal{
    @Override
    public void say(){
        System.out.println("我是一只狗");
    }

    public void f1(){
        System.out.println("汪汪");
    }
}

public class Cat extends Animal{
    @Override
    public void say(){
        System.out.println("我是一只猫");
    }
    public void f2(){
        System.out.println("我喜欢吃鱼");
    }
}

public class Test {
    public static void doSomething(Animal animal){
        animal.say();
        if(animal instanceof Dog) { // 向下转型判断类别
            ((Dog)animal).f1();
        }else{
            ((Cat)animal).f2();
        }

    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        System.out.println("dog对象是否属于Animal类："+(animal instanceof Animal));
        System.out.println("dog对象是否属于Dog类："+(animal instanceof Dog));
        System.out.println("dog对象是否属于Cat类："+(animal instanceof Cat));

        doSomething(new Dog());
        doSomething(new Cat());
    }
}

输出

dog对象是否属于Animal类：true
dog对象是否属于Dog类：true
dog对象是否属于Cat类：false
我是一只狗
汪汪
我是一只猫
我喜欢吃鱼

匿名内部类

• 没有名字，只有实例化

public interface A {
    public void say();
}

public class B implements A{
    @Override
    public void say() {
        System.out.println("B类实现a方法");
    }
}

public class Test {
    public void test(A a){
        a.say();
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.test(new B());

        t.test(new A() {
            @Override
            public void say() {
                System.out.println("匿名内部类，一次性使用");
            }
        });
    }
}

输出

B类实现a方法
匿名内部类，一次性使用

包装类

• 每个基本类型都对应一个包装类
• 装箱和拆箱
  • 装箱：基本类型转换成类
  • 拆箱：包装类转换成基本类型

public class Demo01 {
    public static void main(String[] args) {
        int a=1;
        Integer i = new Integer(a); // 装箱
        int b = i.intValue(); //拆箱

        System.out.println("a="+a);
        System.out.println("i="+i);
        System.out.println("b="+b);
    }
}

• 装箱和拆箱过程是自动进行的

public class Demo02 {
    public static void main(String[] args) {
        Integer i=1; //自动装箱的过程，自动把基本类型转换成类类型
        int i2=i;   // 自动拆箱的过程，自动把类类型转换成基本类型
        System.out.println("i="+i);
        System.out.println("i2="+i2);
    }
}

public class Demo03 {
    public static void main(String[] args) {
        String a="3";
        String b="5";
        int c = Integer.valueOf(a)+Integer.valueOf(b);
        System.out.println("c="+c);
    }
}

设计模式

• 参考《Head First 设计模式》
• 单例模式：懒汉式和饿汉式

/**
 * 饿汉式
 */
public class Singleton {
    /**
     * 构造方法私有
     */
    private Singleton(){

    }
    public static final Singleton single=new Singleton();

    /**
     * 获取实例
     * @return
     */
    public static Singleton getInstance(){
        return single;
    }
}

/**
 * 懒汉式
 */
public class Singleton2 {
    /**
     * 构造方法私有
     */
    private Singleton2(){

    }
    public static Singleton2 single=null;

    /**
     * 获取实例
     * @return
     */
    public synchronized static Singleton2 getInstance(){
        if(single==null){
            single=new Singleton2();
            System.out.println("第一次调用");
        }
        return single;
    }
}