Java面向对象

Posted 2021-02-06 careyzhao

source:http://blog.java1234.com/index.html?typeId=1

Java面向对象三大特性；

封装：类，类里有方法，属性，可以封装很多功能 仅仅对外暴露一些接口，来实现模块化，组建化，和安全性；

继承：Java中的类可以继承，类似子女可以继承父母的东西；来实现可扩展；

多态：Java中的父类接口可以指向子类实现的引用；

类与对象的关系

通俗的举个例子，比如人类是一种类，张三这个人就是人类的具体的一个个体，也就是java中的对象；这就是一个类与对象的关系；

//新建一个Person类，java文件名和类名必须一致
public class Person {
 
    String name; // 在类中，定义一个姓名name字符串属性 可以存在字符串 类似"张三"
    int age; // 在类中，定义一个年龄age属性
     
    /**
     * 定义一个方法  public表示共有 权限最大  void表示返回值是空  speak是方法名 括号里可以加参数
     */
    public void speak(){
        System.out.println("我叫"+name+" 我今年"+age);
    }
     
    public static void main(String[] args) {
        // 定义一个Person类的对象zhangsan
        Person zhangsan;
        // 实例化对象
        zhangsan=new Person();
        // 给对象的name属性赋值
        zhangsan.name="张三";
        // 给对象的age属性赋值
        zhangsan.age=23;
        zhangsan.speak(); // 调用对象的方法
    }
}

内存分析

方法是对象的一部分，也称为行为。

public class Person {
 
    int speak(String name,int age,String ...hobbies){
        System.out.println("我叫"+name+",我今年"+age+"岁了");
        for(String hobby:hobbies){
            System.out.println(hobby+" ");
        }
        // 获取爱好的长度
        int totalHobbies=hobbies.length;
        return totalHobbies;
    }
     
    public static void main(String[] args) {
        Person person=new Person();
        int n=person.speak("张三",23,"游泳","唱歌");
        System.out.println("有"+n+"个爱好");
    }
}

方法的值传递：

值传递 在方法里改变变量的值 作用范围仅仅是方法里 对外面不影响；

引用传递，传递的是地址，对象里的属性在方法里值修改，对外面有影响，我们通过对象.属性可以获取到最新的数据；

class SanWei{
    int b; // 胸围
    int w; // 腰围
    int h; // 腿围
}
 
public class Person {
 
    void speak(int age,SanWei sanWei){
        System.out.println("我今年"+age+"岁了，我的三围是："+sanWei.b+","+sanWei.w+","+sanWei.h);
        age=24; // 作用范围是方法里
        sanWei.b=80; // 胸围改成80
    }
     
    public static void main(String[] args) {
        Person xiaoli=new Person();
        int age=23;
        SanWei sanWei=new SanWei();
        sanWei.b=90;
        sanWei.w=60;
        sanWei.h=90;
        // age传递的是值 ，sanWei是对象，传递的是引用(地址,c里叫指针)
        xiaoli.speak(age,sanWei);
        System.out.println(age);  
        System.out.println(sanWei.b);
    }
}

内存示意图

方法的重载：类里面有两个或者多个重名的方法，但是方法的参数个数、类型、顺序至少有一个不一样，这时候局构成方法重载；

public class Demo01 {
 
    int add(int a,int b){
        System.out.println("方法一");
        return a+b;
    }
     
    /**
     * 方法的重载，参数个数不一样
     * @param a
     * @param b
     * @param c
     * @return
     */
    int add(int a,int b,int c){
        System.out.println("方法二");
        return a+b+c;
    }
     
    /**
     * 方法的重载，参数的类型不一样
     * @param a
     * @param b
     * @return
     */
    int add(int a,String b){
        System.out.println("方法三");
        return a+Integer.parseInt(b);
    }
     
    /**
     * 参数类型个数一样，返回值类型不一样 不算重载，直接会报错，说方法重名
     * @param args
     */
    /*long add(int a,int b){
        return a+b;
    }*/
     
    public static void main(String[] args) {
        Demo01 demo=new Demo01();
        System.out.println(demo.add(1, 2));
        System.out.println(demo.add(1, 2,3));
        System.out.println(demo.add(1, "3"));
    }
}

注意：假如参数个数和类型一样，返回值不一样，不能算重载，直接是编译出错，编译器认为是方法重复了。

java里方法分为 static静态方法和普通方法

所谓静态方法 是加了static修饰词的方法，我们使用的时候 一般用类名.方法 方式调用；

当然也可以用对象.方法 调用； 一般java里的工具类里的工具方法 用static修饰，作为静态方法；

 

递归，就是程序调用自身，我们讲的是方法递归调用，也就是在方法里自己调用自己；

//求阶乘  1*2*3*...*(n-1)*n 
public class Demo {
 
    /**
     * 递归方式
     * @param n
     * @return
     */
    static long diGui(int n){
        if(n==1){
            return 1;
        }
        return diGui(n-1)*n;
    }
     
    public static void main(String[] args) {
        System.out.println(Demo03.diGui(5));
    }
}

/*用递归实现斐波那契数列 1、1、2、3、5、8、13、21、...

   F(1)=1, f(2)=1

   F(N)=F(N-1)+F(N-2)
*/
public class Demo{
 
    long fun(int n){
        if(n==1 || n==2){
            return 1;
        }
        return fun(n-1)+fun(n-2);
    }
     
    public static void main(String[] args) {
        System.out.println(new Test().fun(7));
    }
}

构造方法

概念：构造方法是一个特殊的方法，这个特殊方法用于创建实例时执行初始化操作；

特点 1，没有返回值类型，区别于其他一般方法；

        2，方法名和类名一样；

注意点：

1，假如没有构造方法，系统会自动生成一个默认的无参构造方法；

2，假如有构造方法，系统不会自动生成构造方法；

/**
 * 定义人类
 * @author user
 *
 */
public class People {
 
    // 定义属性 
    private String name; // 实例化对象时，默认值是null
    private int age; // 实例化对象时，默认值是0
     
    /**
     * 默认构造方法
     */
    People(){
        System.out.println("默认构造方法！");
    }
     
    /**
     * 有参数的构造方法
     * @param name2
     * @param age2
     */
    People(String name2,int age2){
        System.out.println("调用的是有参数的构造方法");
        name=name2;
        age=age2;
    }
     
    public void say(){
        System.out.println("我叫："+name+"，我今年："+age);
    }
     
    public static void main(String[] args) {
        // People people=new People();
        People people=new People("张三",20);
        people.say();
    }
}

 

this，关键字，表示当前对象

1，使用this调用本类中的属性；

2，使用this调用构造方法；

/**
 * 定义人类
 * @author user
 *
 */
public class People {
 
    // 定义属性 
    private String name; // 实例化对象时，默认值是null
    private int age; // 实例化对象时，默认值是0
     
    /**
     * 默认构造方法
     */
    People(){
        System.out.println("默认构造方法！");
    }
     
    /**
     * 有参数的构造方法
     * @param name
     * @param age
     */
    People(String name,int age){
        this(); // 调用无参数的构造方法
        System.out.println("调用的是有参数的构造方法");
        this.name=name;
        this.age=age;
    }
     
    public void say(){
        System.out.println("我叫："+name+"，我今年："+age);
    }
     
    public static void main(String[] args) {
        // People people=new People();
        People people=new People("张三",20);
        people.say();
    }
}

运行输出：

默认构造方法！
调用的是有参数的构造方法
我叫：张三，我今年：20

 

 访问控制权限：private(私有)， package(包访问权限)，protected(子类访问权限)，public(公共访问权限)

 

代码块主要就是通过{}花括号 括起来的代码；

主要分为 普通代码块 构造块 静态代码块三类。

普通代码块：仅仅是花括号括起来的代码块；

构造块作用就是扩展构造器功能 每次实例化对象都会执行构造块里的内容，每次调用构造方法 都会先执行 构造块；

静态代码块：{}花括号前加static修饰词 在类加载的时候执行 而且只执行一次；

 

String类

实例化String对象

public static void main(String[] args) {
        // 实例化String的方式一
        String name1="张三";
        System.out.println("name1="+name1);
         
        // 实例化String的方式二
        String name2=new String("李四");
        System.out.println("name2="+name2);
}

“==”VS“equals方法”

“==” 比较的是引用(是否指向同一个内存块)  “equals”比较的是具体内容；

public static void main(String[] args) {
        String name1="张三";  // 直接赋值方式
        String name2=new String("张三"); // new方式
        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两种实例化方式的区别：

直接赋值方式，创建的对象存放到字符串对象池里，假如存在的，就不会再创建；

new对象方式，每次都创建一个新的对象；

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

字符串的内容不可变性

字符串的特性：不能改变字符串的内容；

要想改变，只能通过指向一个新的内存地址；

public static void main(String[] args) {
        String name="张";
        name+="三";
        System.out.println(name);
}

String类的常用方法：

 1、char chartAt(int index) 返回指定索引处的char值，这里的index 是从0开始的

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));
        }
}

运行输出：

三

我

是

中

国

人

2、int length() 返回字符串的长度

3、int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。

public static void main(String[] args) {
        // indexOf方法使用实例
        String str="abcdefghijdklmoqprstuds";
        System.out.println("d在字符串str中第一次出现的索引位置："+str.indexOf(‘d‘));
        System.out.println("d在字符串str中第一次出现的索引位置,从索引4位置开始："+str.indexOf(‘d‘,4));
}

4、String substring(int beginIndex)   返回一个新的字符串，它是此字符串的一个子字符串。

public static void main(String[] args) {
        // substring方式读取
        String str="不开心每一天";
        String str2="不开心每一天，不可能";
        String newStr=str.substring(1);
        System.out.println(newStr);
        String newStr2=str2.substring(1, 6);
        System.out.println(newStr2);
}

5、public String toUpperCase()  String 中的所有字符都转换为大写

public static void main(String[] args) {
        String str="I‘m a boy!";
        String upStr=str.toUpperCase(); // 转成大写
        System.out.println(upStr);
        String lowerStr=upStr.toLowerCase(); // 转成小写
        System.out.println(lowerStr);
}

String类综合案例

//“ aB232 23 &*( s2 ”指定字符串，要求去掉前后空格，然后分别统计其中英文字符，空格，数字和其他字符的个数；
public static void main(String[] args) {
        String str=" aB232 23 &*( s2 ";
        String newStr=str.trim(); // 去掉前后空格
        System.out.println("str="+str);
        System.out.println("newStr="+newStr);
         
        int yingWen=0; // 英文个数
        int kongGe=0; // 空格个数
        int shuZi=0; // 数字个数
        int qiTa=0; // 其他
         
        for(int i=0;i<newStr.length();i++){
            char c=newStr.charAt(i);
            // 判断英文字符
            if((c>=‘a‘&&c<=‘z‘)||(c>=‘A‘&&c<=‘Z‘)){
                yingWen++;
                System.out.println("英文字符："+c);
            }else if(c>=‘0‘&&c<=‘9‘){
                shuZi++;
                System.out.println("数字字符："+c);
            }else if(c==‘ ‘){
                kongGe++;
                System.out.println("空格字符："+c);
            }else{
                qiTa++;
                System.out.println("其他字符："+c);
            }
        }
         
        System.out.println("英文个数："+yingWen);
        System.out.println("空格个数："+kongGe);
        System.out.println("数字个数："+shuZi);
        System.out.println("其他个数："+qiTa);
}

//字符串反转，“abcdefg”,通过编程得到一个新的字符串“gfedcba”
public static void main(String[] args) {
        String str="abcdefg";
        String newStr="";
        for(int i=str.length()-1;i>=0;i--){
            newStr+=str.charAt(i);
        }
        System.out.println(newStr);
}

//将字符串“1,3,5,7,9”，转换成数组，数组元素是整数元素1,3,5,7,9 ,
注意：这里需要使用int的包装类的parseInt方法 把字符串转成int类型；
public static void main(String[] args) {
        String str="1,3,5,7,9";
        int shuZi=0;
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)!=‘,‘){
                shuZi++;
            }
        }
        int []arr=new int[shuZi];
        int j=0;
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)!=‘,‘){
                arr[j]=Integer.parseInt(str.charAt(i)+"");
                j++;
            }
        }
        for(int a:arr){
            System.out.print(a+" ");
        }
}