java基础韩顺平老师的面向对象（基础）自己记的部分笔记

194，对象内存布局

基本数据类型放在堆里面，字符串类型放在方法区。

栈：一般存放基本数据类型（局部变量）

堆：存放对象（Cat cat，数组等）

方法区：常量池（常量，比如字符串），类加载信息

196，属性注意细节

1，属性可以是基本数据类型，也可以是引用类型（对象，数组）

2，属性的定义语法同变量，示例：访问修饰符属性类型属性名；这里简单介绍访问修饰符：控制属性的访问范围。有四种访问修饰符 public，protected，默认，private。

3，属性如果不赋值，有默认值，规则和数组一致。具体说：int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000，boolean false，String null。

public class test1{
    public static void main(String[] args){
        //创建Person对象
        //p1 是对象名（对象引用）
        Person p1 = new Person();//new Person() 创建的对象空间（数据）才是真正的对象

        System.out.println("\n当前这个人的信息");
        System.out.println("age = " + p1.age + " name = " + p1.name + " sal = " + p1.sal + " isPass = " + p1.isPass);
    }
}
class Person{
    //四个属性
    int age;
    String name;
    double sal;
    String isPass;
}

运行结果：

198，对象分配机制

引用赋值，即地址赋值

199，对象创建过程

1，先加载Person类信息（属性和方法信息，只会加载一次）

2，在堆中分配空间，进行默认初始化（看规则）

3，把地址赋给 p ，p 就指向对象 Person p = new Person()

4，进行指定初始化，比如 p.name = "jack"

206，方法使用细节

1，一个方法最多有一个返回值 [思考，如何返回多个结果，返回数组]

2，返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）

public class test1{
    public static void main(String[] args){
        AA a = new AA();
        int[] res = a.getSumAndSub(1,2);//用一个数组接收
        System.out.println("和 = " + res[0]);
        System.out.println("差 = " + res[1]);
    }
}
class AA{
    public int[] getSumAndSub(int n1, int n2)
    {
        int[] resArr = new int[2];//创建一个数组
        resArr[0] = n1 + n2;
        resArr[1] = n1 - n2;
        return resArr;
    }
}

运行结果：

3，如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值（值为常量或表达式）；而且要求返回值类型必须和 return 的值类型一致或兼容（会发生自动类型转换）

4，如果方法是 void ，则方法体中可以没有 return 语句，或者只写 return；

5，接207；一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开

6，调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数

7，方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容，个数，顺序必须一致

8，方法体里面写完功能的具体的语句，可以为输入，输出，变量，运算，分支，循环，方法调用，但里面不能再定义方法！即：方法不能嵌套定义。

9，同一个类中的方法调用：直接调用即可。（我们想在A类里的一个方法里去调用A类里的另一个方法，直接调用即可）

public class test1{
    public static void main(String[] args){
        A a = new A();
        a.sayOk();
    }
}
class A{
   public void print(int n)
   {
       System.out.println("print()方法被调用 n = " + n);
   }
   public void sayOk()// sayOk 调用 print(直接调用即可）
   {
       print(10);
       System.out.println("继续执行sayOk");
   }
}

运行结果：

10，跨类中的方法A类调用B类方法：需要通过对象名调用。（我们想在A类的一个方法里调用B类的一个方法，需要在A类的这个方法里创建B类的对象，再用B类的对象调用B类的一个方法）。

public class test1{
    public static void main(String[] args){
        A a = new A();
        a.m1();
    }
}
class A{
   public void m1()
   {
       System.out.println("m1() 方法被调用");
       B b = new B();//创建B对象
       b.hi();
       System.out.println("m1() 方法继续执行");
   }
}
class B{
    public void hi()
    {
        System.out.println("B类中的 hi() 被执行");
    }
}

运行结果：

11，特别说明一下：跨类的方法调用和方法的访问修饰符相关，后面会细说。

213，克隆对象

编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象，注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同。

public class test1{
    public static void main(String[] args){
        Person p = new Person();
        p.name = "milan";
        p.age = 100;
        //创建tools对象
        MyTools tools = new MyTools();
        Person p2 = tools.copyPerson(p);

        //到此 p 和 p2 是 Person对象，但是是两个独立的对象，属性相同
        System.out.println("p的属性 age = " + p.age + " 名字 = " + p.name);
        System.out.println("p2的属性 age = " + p2.age + " 名字 = " + p2.name);
    }
}
class Person{
    String name;
    int age;
}
class MyTools{
    //方法的返回类型 Person
    // 方法的名字 copyPerson
    // 方法的形参(Person p)
    //方法体，创建一个新对象，并复制属性，返回即可
    public Person copyPerson(Person p)
    {
        Person p2 = new Person();
        p2.name = p.name;//把原来对象的名字赋给p2.name
        p2.age = p.age;//把原来对象的年龄赋给p2.age
        return p2;
    }
}

运行结果：

218，递归执行机制

1，执行一个方法时，就创建一个新的受保护的独立空间（栈空间）

2，方法的局部变量是独立的，不会相互影响，比如n变量

3，如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据

4，递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError

5,当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

220，猴子吃桃

有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到了第10天时，想再吃时（即还没吃完），发现只有1个桃子了。问题：最初共多少个桃子？

（已知第10天只剩1个桃子，猴子每天都吃其中的一半，并多吃一个。假设第9天有 x 个桃子，第 10天有 y 个桃子，(x / 2) - 1 = y，x = (y + 1) * 2）

思路：逆推

1，day = 10 时，有 1 个桃子

2，day = 9 时，有（day10 + 1）* 2 = 4

3，day = 8 时，有（day9 + 1）* 2 = 10

4，规律就是前一天的桃子 = （后一天的桃子 + 1）* 2

5，递归

public class test1{
    public static void main(String[] args){
       T t = new T();
       int day = 1;
       int peachNum = t.peach(day);
       if(peachNum != -1)
       {
           System.out.println("第" + day + "天有" + peachNum + "个桃子");
       }
    }
}
class T{
    public int peach(int day)
    {
        if(day == 10)
        {
            return 1;
        }else if(day >= 1 && day <= 9)
        {
            return (peach(day + 1) + 1) * 2;
        }
        else
        {
            System.out.println("day在1-10");
            return -1;
        }
    }
}

运行结果：

221，老鼠出迷宫

思路：

1，先创建迷宫，用二维数组表示 int[][] map = new int[8][7]

2，先规定map 数组的元素值：0 表示可以走；1 表示障碍物

3，将最上面的一行和最下面的一行，全部设置为1

4，将最右面的一列和最左面的一列，全部设置为1

使用递归回溯的思想来解决老鼠出迷宫

1，findWay方法就是专门来找出迷宫的路径

2，如果找到，就返回 true，否则返回 false

3，map 就是二维数组，即表示迷宫

4，i，j 就是老鼠的位置，初始化的位置为（1,1）

5，因为我们是递归的找路，所以先规定 map 数组的各个值的含义：0 表示可以走；1 表示障碍物；2 表示可以走；3 表示走过，但是走不通，是死路

6，当 map[6][5] = 2 就说明找到通路，就可以结束，否则就继续找

7，先确定老鼠找路策略：下 -> 右 -> 上 -> 左。（有不同的策略，先确定一个自己的策略）

public class test1{
    public static void main(String[] args){
       int[][] map = new int[8][7];//8行7列
       for(int i = 0; i < 7; i++) //i 是列，
       {
           map[0][i] = 1;//将最上面的一行和最下面的一行，全部设置为1
           map[7][i] = 1;
       }
       for(int i = 0; i < 8; i++)//i 是行
       {
           map[i][0] = 1;//将最右面的一列和最左面的一列，全部设置为1
           map[i][6] = 1;
       }
       map[3][1] = 1;
       map[3][2] = 1;
       //输出当前地图
        for(int i = 0; i < map.length; i++)
        {
            for(int j = 0; j < map[i].length; j++)
            {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
        //使用findWay给老鼠找路
        T t1 = new T();
        t1.findWay(map,1,1);//对数组的修改，会把原数组修改了，参考引用赋值
        System.out.println("\n====找路的情况如下=====");
        for(int i = 0; i < map.length; i++)
        {
            for(int j = 0; j < map[i].length; j++)
            {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}
class T{
    public boolean findWay(int[][] map, int i, int j)
    {
        //0 表示可以走，还没走；1 表示障碍物；2 表示可以走；3 表示走过，但是走不通，是死路
        if (map[6][5] == 2) //说明已经找到，走到终点了
        {
            return true;
        }
        else
        {
            if (map[i][j] == 0)//当前位置为0，也是起点。说明可以走
            {
                map[i][j] = 2;//假定可以走通，沿着找路策略开始走
                //找路策略：下 -> 右 -> 上 -> 左
                if (findWay(map, i + 1, j))//下
                {
                    return true;
                } else if (findWay(map, i, j + 1))//右
                {
                    return true;
                } else if (findWay(map, i - 1, j))//上
                {
                    return true;
                } else if (findWay(map, i, j - 1)) //左
                {
                    return true;
                }
                else//四个方向都走不通了，就是死路
                {
                    map[i][j] = 3;
                    return false;
                }
            }
            else //map[i][j] = 1,2,3
            {
                return false;
            }
        }
    }
}

运行结果：

225，汉诺塔

思路见代码：

public class test1{
    public static void main(String[] args){
        T t = new T();
        t.move(3, 'A', 'B', 'C');
    }
}
class T{
    //num 表示要移动的个数，a,b,c分别表示A塔，B塔，C塔
   public void move(int num, char a, char b, char c)
   {
       if(num == 1)//只有一个盘子，就直接从A移到C
       {
           System.out.println(a + "->" + c);
       }
       else
       {
           //1，如果有多个盘，可以看成两个，最下面的和上面的所有盘(num-1)
           move(num - 1,a, c, b);//先移动上面的所有的盘到 b，借助 c，借助是指我们不能把上面的所有盘整体移过去，需要借助c
           System.out.println(a + "->" + c); //3，把最下面的这个盘，移动到 c。
           //4，再把 b 塔的所有盘，移动到 c，借助 a
           move(num - 1, b, a, c);//把B塔的盘移动也当成两个盘在移动，和上面的 1 同理
       }
   }
}

运行结果：

229，重载使用细节

1，方法名：必须相同

2，形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）

3，返回类型：无要求

233，可变参数使用

概念：java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现。

基本语法：访问修饰符返回类型方法名（数据类型... 形参名）{}

public class test1{
    public static void main(String[] args){
        HspMethods m = new HspMethods();
        System.out.println(m.sum(1,2,3,4));
    }
}
class HspMethods{
    //可以计算 2个数的和，3个数的和，4，5....
    //可以使用方法重载
//    public int sum(int n1, int n2)//2个数的和
//    {
//        return n1 + n2;
//    }
//    public int sum(int n1, int n2, int n3)//3个数的和
//    {
//        return n1 + n2;
//    }
    //上面的两个方法名称相同，功能相同，参数个数不同 -> 使用可变参数优化
    //1，  int... 表示接受的是可变参数，类型是int，即可以接收多个int（0-多）
    //2，  使用可变参数是，可以当做数组来使用，即 nums 可以当做数组
    public int sum(int... nums)
    {
        int res = 0;
        for(int i = 0; i < nums.length; i++)
        {
            res += nums[i];
        }
        return res;
    }
}

运行结果：

234，可变参数细节

1，可变参数的实参可以为 0 个或任意多个（见 233 代码）

2，可变参数的实参可以为数组

public class test1{
    public static void main(String[] args){
        int[] arr = {1, 2, 3};
        T t1 = new T();
        t1.f1(arr);
    }
}
class T{
   public void f1(int... nums)
   {
       System.out.println("长度 = " + nums.length);
   }
}

运行结果：

3，可变参数的本质就是数组

4，可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后（否则报错）

public void f2(String str, double... nums){}

5，一个形参列表中只能出现一个可变参数

235，可变参数练习

问题：有三个方法，分别实现返回姓名和两门课成绩（总分），返回姓名和三门课成绩（总分），返回姓名和五门课成绩（总分）。封装成一个可变参数的方法。类名 HspMethod 方法名 showScore

分析：两门课，三门课，五门课成绩，理解为一个可以接收多个double 类型的可变参数，问题要求返回姓名和三门课成绩（总分），所以方法的返回类型是 String，形参(String, double... )

public class test1{
    public static void main(String[] args){
        HspMethod t1 = new HspMethod();
        System.out.println(t1.showScore("milan", 60,80));
        System.out.println(t1.showScore("jack", 60,80,80));
        System.out.println(t1.showScore("lucy", 60,80,80,90,80));
    }
}
class HspMethod{
   public String showScore(String name, double... scores)
   {
       double totalScore = 0;
       for(int i = 0; i < scores.length; i++)
       {
           totalScore += scores[i];
       }
       return name + " 有" + scores.length + "门课的成绩总分 = " + totalScore;
   }
}

运行结果：

236，作用域基本使用

1，在java编程中，主要的变量就是属性（成员变量）和局部变量

2，我们说的局部变量一般是指在成员方法中定义的变量

3，java 中作用域的分类。

全局变量：也就是属性，作用域为整个类体；

局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中！

4，全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后才能使用，因为没有默认值。

237，作用域使用细节

1，属性和局部变量可以重名，访问时遵循就近原则。

public class test1{
    public static void main(String[] args){
        Person p1 = new Person();
        p1.say();
    }
}
class Person{
    String name = "jack";
    public void say()
    {   
        String name = "king";
        System.out.println("say() name = " + name);
    }
}

运行结果：

2，在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名

3，属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。

4，全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）。局部变量：只能在本类中对应的方法中使用

public class test1{
    public static void main(String[] args){
        Person p1 = new Person();
        T t1 = new T();
        t1.test();//第1种跨类访问对象属性的方式
        t1.test(p1);//第2种跨类访问对象属性的方式

    }
}
class T{
    public void test()
    {
        Person p1 = new Person();//Person类中的全局变量name，可以在T类中使用，通过对象调用
        System.out.println(p1.name);//jack
    }
    public void test(Person p)
    {
        System.out.println(p.name);//jack
    }
}
class Person{
    String name = "jack";
}

运行结果：

5，修饰符不同：全局变量/属性可以加修饰符；局部变量不可以加修饰符

239，构造器基本介绍

构造方法又叫构造器，是类的一种特殊方法，它的主要作用是完成对新对象的初始化

基本语法：修饰符方法名(形参列表) { 方法体 }

说明：1，构造器的修饰符可以默认，也可以是public protected private

2，构造器没有返回值

3，方法名和类名字必须一样

4，参数列表和成员方法一样的规则

5，在创建对象时，系统会自动调用该类的构造器完成对对象的初始化

public class test1{
    public static void main(String[] args){
        Person p1 = new Person("smith", 80);//当我们new 一个对象时，直接通过构造器指定名字和年龄
        System.out.println("p1的信息如下");
        System.out.println("p1对象name = " + p1.name);
        System.out.println("p1对象age = " + p1.age);
    }
}
class Person{
    String name;
    int age;
    public Person(String pName, int pAge)
    {
        System.out.println("构造器被调用~~ 完成对象的属性初始化");
        name = pName;
        age = pAge;
    }
}

运行结果：

6，一个类可以定义多个不同的构造器，即构造器重载

7，如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造器），比如 Dog() { }

8，一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显示的定义一下，即：Dog() {}

244，对象创建的流程分析

看一个案例

class Person{//类Person
    int age = 90;
    String name;
    Person(String n, int a)//构造器
    {
        name = n;//给属性赋值
        age = a;
    }
}
Person p = new Person("小倩",20);

流程分析（面试题）

1，加载Person类信息（Person.class），只会加载一次

2，在堆中分配空间（地址）

3，完成对象初始化

3.1，默认初始化 age = 0，name = null 3.2，显示初始化 age = 90，name = null 3.3，构造器的初始化 age = 20，name = 小倩

4，在对象在堆中的地址，返回给 p（p是对象名，也可以理解成是对象的引用）

249，this 使用细节

1，哪个对象调用，this就代表哪个对象

2，this 关键字可以用来访问本类的属性，方法，构造器

3，this用于区分当前类的属性和局部变量

4，访问成员方法的语法：this.方法名(参数列表)

public class test1{
    public static void main(String[] args){
        T t = new T();
        t.f2();
    }
}
class T{
    public void f1()
    {
        System.out.println("f1() 方法..");
    }
    public void f2()
    {
        System.out.println("f2() 方法..");
        //调用本类的 f1
        f1();//第一种方式
        this.f1();//第二种方式 this.方法名（参数列表）
    }
}

运行结果：

5，访问构造器语法：this(参数列表)；注意只能在构造器中使用（即只能在构造器中访问另外一个构造器，必须放置第一条语句）

public class test1{
    public static void main(String[] args){
        T t = new T();
    }
}
class T{
    public T()
    {
        this("jack", 100);//这里去访问T(String name, int age) 构造器
        System.out.println("T() 构造器");
    }
    public T(String name, int age)
    {
        System.out.println("T(String name, int age) 构造器");
    }
}

运行结果：

6，this不能在类定义的外部使用，只能在类定义的方法中使用

250，this课堂练习

问题：定义Person类，里面有name，age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson 用于测试，名字和年龄完全一样，就返回true，否则返回false

public class TestPerson{
    public static void main(String[] args){
        Person p1 = new Person("mary", 20);
        Person p2 = new Person("smith", 30);
        System.out.println(p1.compareTo(p2));

    }
}
class Person{
    String name;
    int age;
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    public boolean compareTo(Person p)//和另一个人的姓名年龄比较，所以形参是Person对象，还要知道这个对象的信息（通过构造器）
    {
        return this.name.equals(p.name) && this.age == p.age;
    }
}

运行结果：

253，本章作业03

问题：编写类Book，定义方法updatePrice，实现更改某本书的价格，具体：如果价格>150，则更改为150，如果价格>100，更改为100，否则不变。

分析：更改某本书的价格，可以理解为更改一个对象的价格属性，需要先用构造器完成对这个对象的价格的初始化，再到方法中进行更改。

public class test1{
    public static void main(String[] args){
        Book book = new Book("小王子", 120);
        book.info();
        book.updatePrice();
        book.info();
    }
}
class Book
{
    String name;
    double price;
    public Book(String name, double price)
    {
        this.name = name;
        this.price = price;
    }
    public void updatePrice()
    { //如果方法中，没有 price 局部变量，this.price 等价 price
        if(price > 100)
        {
            price = 100;
        }else if(price > 150)
        {
            price = 150;
        }
    }
    public void info()
    {
        System.out.println("书名 = " + this.name + " 价格 = " + this.price);
    }
}

运行结果：

260，本章作业10

public class test1 {
    public static void main(String[] args) {
        Circle c = new Circle();
        PassObject po = new PassObject();
        po.printAreas(c,5);
    }
}
class Circle
{
    double radius;
    public Circle()//在第2问我们没有办法确认半径值，在for循环那里才知道半径值是变化的,所以要重写默认构造器
    {

    }
    public Circle(double radius)//第1问要用到这个
    {
        this.radius = radius;
    }
    public double findArea()//返回面积
    {
        return radius * radius * Math.PI;
    }
    public void setRadius(double radius)//添加方法 setRadius,修改对象的半径值
    {
        this.radius = radius;
    }
}
class PassObject
{
    public void printAreas(Circle c, int times)
    {
        System.out.println("radius\tarea");
        for(int i = 1; i <= times; i++)
        {
            c.setRadius(i);//可以用到Circle对象，并能把i传进去，如果每次都new 一个新对象（用构造器），就不划算
            System.out.println(i + "\t" + c.findArea());

        }
    }
}

运行结果：

posted @ 2024-03-07 20:33 银河小船儿阅读(51) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

romantichuaner

java基础韩顺平老师的面向对象（基础）自己记的部分笔记

194，对象内存布局

196，属性注意细节

198，对象分配机制

199，对象创建过程

206，方法使用细节

213，克隆对象

220，猴子吃桃

221，老鼠出迷宫

225，汉诺塔

229，重载使用细节

233，可变参数使用

234，可变参数细节

235，可变参数练习

236，作用域基本使用

237，作用域使用细节

239，构造器基本介绍

244，对象创建的流程分析

流程分析（面试题）

249，this 使用细节

250，this课堂练习

253，本章作业03

260，本章作业10

公告

romantichuaner

java基础 韩顺平老师的 面向对象（基础） 自己记的部分笔记

194，对象内存布局

196，属性注意细节

198，对象分配机制

199，对象创建过程

206，方法使用细节

213，克隆对象

220，猴子吃桃

221，老鼠出迷宫

225，汉诺塔

229，重载使用细节

233，可变参数使用

234，可变参数细节

235，可变参数练习

236，作用域基本使用

237，作用域使用细节

239，构造器基本介绍

244，对象创建的流程分析

流程分析（面试题）

249，this 使用细节

250，this课堂练习

253，本章作业03

260，本章作业10

公告

java基础韩顺平老师的面向对象（基础）自己记的部分笔记