Java基础(3)-面向对象

写于2019.5.16

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

访问控制权限、package、import

访问权限

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

注：Package为缺省的访问权限

package

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

import
导入包

内部类和代码块

内部类

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

/**
 * 外部类
 */
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

代码块

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

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类

两种比较

形式	功能
==	比较引用的位置是否相同
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

两种实例化方法的区别

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

String的内容不可修改
常用方法

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

具体参考：JDK_API_1_6_zh_CN

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关键字和抽象类

final

终结，完结

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

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

}

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

抽象类

含有一个抽象方法的类称为抽象类
至少含有一个抽象方法
抽象类和抽象方法都需要使用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;
    }
}

posted on 2019-05-16 20:26 vincent_zhu 阅读(91) 评论(0) 编辑收藏举报

刷新页面返回顶部

vincent_zhu

导航

公告

Java基础(3)-面向对象

访问控制权限、package、import

内部类和代码块

String类

继承

final关键字和抽象类

接口

多态性

Object类

instancesof关键字

匿名内部类

包装类

设计模式