Java300集day04——Java面向对象基础 Java

1.面向对象具有三大特征：封装性、继承性和多态性，而面向过程没有继承性和多态性，并且面向过程的封装只是封装功能，而面向对象可以封装数据和功能。所以面向对象优势更明显。
2.类：我们叫做class。对象：我们叫做Object,instance(实例)。以后我们说某个类的对象，某个类的实例。是一样的意思。
3.内存分析详解、栈、堆、方法区、栈帧

public class SxtStu { int id; String sname; int age; Computer comp; //计算机 void study() { System.out.println("我再认真学习哦！！！"+comp.brand); } void play() { System.out.println("我在玩游戏，王者农药！！！"); } //构造方法。用于创建这个类的对象。无参的构造方法可以由系统自动创建 SxtStu(){ } public static void main(String[] args) { // TODO Auto-generated method stub SxtStu stu = new SxtStu(); stu.id = 1001; stu.sname = "郭川川"; stu.age = 19; Computer c1 = new Computer(); c1.brand = "联想"; stu.comp = c1; stu.play(); stu.study(); }} class Computer{ String brand; }

文章图片

4.构造方法详解：
要点：
1. 通过new关键字调用!!
2. 构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
3. 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
4. 构造器的方法名必须和类名一致!

class Point { double x, y; /*public Point(){如果不自己加构造方法，系统自己生成的构造方法} */ public Point(double _x, double _y) {//人为的构造方法,构造方法与类名一致 x = _x; y = _y; } public double getDistance(Point p) { return Math.sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y)); } } public class TestConstructor { public static void main(String[] args) { Point p = new Point(3.0, 4.0); Point origin = new Point(0.0, 0.0); System.out.println(p.getDistance(origin)); } }

方法的重载：

public class User { int id; // id String name; // 账户名 String pwd; // 密码 public User() { } public User(int id, String name) {//this.id代表的属性id,id代表形参id super(); this.id = id; this.name = name; } public User(int id, String name, String pwd) { this.id = id; this.name = name; this.pwd = pwd; } public static void main(String[] args) { User u1 = new User(); User u2 = new User(101, "高小七"); User u3 = new User(100, "高淇", "123456"); } }

5.垃圾回收机制：Java有专门的垃圾回收器
垃圾回收算法：引用计数法、引用可达法
6.
this最常的用法：
1.在程序中产生二义性之处，应使用this来指明当前对象; 普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
2. 使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
3. this不能用于static方法中。
this代表当前对象实例：

public class User { int id; //id String name; //账户名 String pwd; //密码 public User() { } public User(int id, String name) { System.out.println("正在初始化已经创建好的对象："+this); this.id = id; //不写this，无法区分局部变量id和成员变量id this.name = name; } public void login(){ System.out.println(this.name+",要登录！"); //不写this效果一样 }public static void main(String[] args) { Useru3 = new User(101,"高小七"); System.out.println("打印高小七对象："+u3); u3.login(); } }

this调用重载构造方法

public class TestThis {

int a, b, c;

TestThis() {

System.out.println("正要初始化一个Hello对象");

}
TestThis(int a, int b) {

// TestThis();
 //这样是无法调用构造方法的！

this();
 // 调用无参的构造方法，并且必须位于第一行！

a = a;
// 这里都是指的局部变量而不是成员变量

// 这样就区分了成员变量和局部变量. 这种情况占了this使用情况大多数！

this.a = a;

this.b = b;

}
TestThis(int a, int b, int c) {

this(a, b);
 // 调用带参的构造方法，并且必须位于第一行！

this.c = c;

}

void sing() {
}
void eat() {

this.sing();
 // 调用本类中的sing();

System.out.println("你妈妈喊你回家吃饭！");

}

public static void main(String[] args) {

TestThis hi = new TestThis(2, 3);

hi.eat();

}
}

7. static修饰的成员变量和方法从属于类；普通变量和方法从属于对象。

** * 测试static关键字的用法 * @author 高淇 * */ public class User2 { int id; // id String name; // 账户名 String pwd; // 密码static String company = "北京尚学堂"; // 公司名称public User2(int id, String name) { this.id = id; this.name = name; }public void login() { printCompany(); System.out.println(company); System.out.println("登录：" + name); }public static void printCompany() { //login(); //调用非静态成员，编译就会报错 System.out.println(company); }public static void main(String[] args) { User2 u = new User2(101, "高小七"); User2.printCompany(); User2.company = "北京阿里爷爷"; User2.printCompany(); } }

文章图片

总结：this代表当前对象；先加载静态变量、静态方法，后加载对象中的普通变量和方法；静态变量和静态方法从属于类。
8.static初始块化：构造方法用于对象的初始化!静态初始化块，用于类的初始化操作!在静态初始化块中不能直接访问非static成员。

public class User3 { int id; //id String name; //账户名 String pwd; //密码 static String company; //公司名称 static { System.out.println("执行类的初始化工作"); company = "北京尚学堂"; printCompany(); } public static void printCompany(){ System.out.println(company); } public static void main(String[] args) { User3u3 = new User3(); } }

9.参数传值机制：
基本数据类型参数的传值
传递的是值的副本。副本改变不会影响原件。
· 引用类型参数的传值
传递的是值的副本。但是引用类型指的是“对象的地址”。因此，副本和原参数都指向了同一个“地址”，改变“副本指向地址对象的值，也意味着原参数指向对象的值也发生了改变”。

/** * 测试参数传值机制 * @author 高淇 * */ public class User4 { int id; //id String name; //账户名 String pwd; //密码public User4(int id, String name) { this.id = id; this.name = name; }publicvoidtestParameterTransfer01(User4u){ u.name="高小八"; }publicvoidtestParameterTransfer02(User4u){ u=newUser4(200,"高三"); }public static void main(String[] args) { User4u1=new User4(100, "高小七"); u1.testParameterTransfer01(u1); System.out.println(u1.name); u1.testParameterTransfer02(u1); System.out.println(u1.name); } }

内存解析：

文章图片

9.包的使用：解决类重名的问题
package的使用有两个要点：
1. 通常是类的第一句非注释性语句。
2. 包名：域名倒着写即可，再加上模块名，便于内部管理类。

文章图片

10.import导入类
注意要点：
1. Java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
2. 如果导入两个同名的类，只能用包名+类名来显示调用相关类：

1	`java.util.Date date= newjava.util.Date();`

【示例4-15】导入同名类的处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14 import java.sql.Date;
import java.util.*; //导入该包下所有的类。会降低编译速度，但不会降低运行速度。

public class Test{
public static void main(String[] args) {
//这里指的是java.sql.Date
Date now;
//java.util.Date因为和java.sql.Date类同名，需要完整路径
java.util.Datenow2 = new java.util.Date();
System.out.println(now2);
//java.util包的非同名类不需要完整路径
Scanner input = new Scanner(System.in);
}
}

静态导入：
【示例4-16】静态导入的使用

1
2
3
4
5
6
7
8
9
10
11 package cn.sxt;
//以下两种静态导入的方式二选一即可
import static java.lang.Math.*; //导入Math类的所有静态属性
import static java.lang.Math.PI; //导入Math类的PI属性

public class Test2{
public static void main(String [] args){
System.out.println(PI);
System.out.println(random());
}
}

总结:
　1. 面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。但是具体到实现部分的微观操作(就是一个个方法)，仍然需要面向过程的思路去处理。
2. 类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
3. 对于一个类来说，一般有三种常见的成员：属性field、方法method、构造器constructor。
4. 构造器也叫构造方法，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。
5.Java引入了垃圾回收机制，令C++程序员最头疼的内存管理问题迎刃而解。Java程序员可将更多的精力放到业务逻辑上而不是内存管理工作，大大提高开发效率。
6. this的本质就是“创建好的对象的地址”! this不能用于static方法中。
7.在类中，用static声明的成员变量为静态成员变量，也称为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。在static方法中不可直接访问非static的成员。
8.Java方法中所有参数都是“值传递”，也就是“传递的是值的副本”。也就是说，我们得到的是“原参数的复印件，而不是原件”。因此，复印件改变不会影响原件。
9. 通过package实现对类的管理; 如果我们要使用其他包的类，需要使用import导入，从而可以在本类中直接通过类名来调用。
作业：

一、选择题
1.以下语句中关于Java构造方法的说法错误的是( )。(选择一项)
A.构造方法的作用是为创建对象进行初始化工作，比如给成员变量赋值
B.一个Java类可以没有构造方法，也可以提供1个或多个构造方法
C.构造方法与类同名，不能书写返回值类型
D.构造方法的第一条语句如果是super()，则可以省略，该语句作用是调用父类无参数的构造方法
2.在Java中，以下程序编译运行后的输出结果为( )。(选择一项)

1
2
3
4
5
6
7
8
9
10
11
12
13 public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}

A.6
B.34
C.8
D.7
3.在Java中关于静态方法，以下说法中正确的是( )。(选择二项)
A.静态方法中不能直接调用非静态方法
B.非静态方法中不能直接调用静态方法
C.静态方法可以用类名直接调用
D.静态方法里可以使用this
4.下列选项中关于Java中类方法的说法错误的是( )。(选择二项)
A.在类方法中可用this来调用本类的类方法
B.在类方法中调用本类的类方法时可直接调用
C.在类方法中只能调用本类中的类方法
D.在类方法中调用实例方法需要先创建对象
5.分析如下Java程序的代码所示，则编译运行后的输出结果是( )。(选择一项)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 public class Test {
int count=9;
public void count1(){
count=10;
System.out.print("count1="+count);
}
public void count2(){
System.out.print("count2="+count);
}
public static void main(String[ ] args) {
Test t=new Test();
t.count1();
t.count2();
}
}

A.count1=9; count2=9;
B.count1=10; count2=9;
C.count1=10; count2=10;
D.count1=9; count2=10;
二、简答题
1. 面向过程和面向对象的区别。
2. 类和对象的关系
3. 构造方法的作用和特征
4. this关键字的作用和用法
5. 简述static关键字的作用。
提示：从static可以修饰变量，方法，代码块，三个方面来回答。
三、编码题
1. 编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。该类中应该有两个私有属性：姓名 (name) 和年龄 (age) 。定义构造方法用来初始化数据成员。再定义显示(display()) 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。
2. 定义一个圆类——Circle，在类的内部提供一个属性：半径(r)，同时提供两个方法：计算面积 ( getArea() ) 和计算周长(getPerimeter()) 。通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。
【Java300集day04——Java面向对象基础】3. 构造方法与重载：定义一个网络用户类，信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入，其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。