Java300集day04——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;
}

Java300集day04——Java面向对象基础_第1张图片 

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) {
        User  u3 = 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();
    }
}

Java300集day04——Java面向对象基础_第2张图片 

总结: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) {
        User3  u3 = 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;
    }
      
    public   void   testParameterTransfer01(User4  u){
        u.name="高小八";
    }
     
    public   void   testParameterTransfer02(User4  u){
        u  =  new  User4(200,"高三");
    }
      
    public static void main(String[] args) {
        User4   u1  =  new User4(100, "高小七");
         
        u1.testParameterTransfer01(u1); 
        System.out.println(u1.name);
 
        u1.testParameterTransfer02(u1);
        System.out.println(u1.name);
    }
}

 内存解析:

Java300集day04——Java面向对象基础_第3张图片

9.包的使用:解决类重名的问题

package的使用有两个要点:

  1. 通常是类的第一句非注释性语句。

  2. 包名:域名倒着写即可,再加上模块名,便于内部管理类。

 Java300集day04——Java面向对象基础_第4张图片

10.import导入类

注意要点:

  1. Java会默认导入java.lang包下所有的类,因此这些类我们可以直接使用。

  2. 如果导入两个同名的类,只能用包名+类名来显示调用相关类: 

1

java.util.Date date  = new  java.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.Date  now2 = 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(33);

        pt2 = new Test(44);

        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 类进行使用。

  3. 构造方法与重载:定义一个网络用户类,信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入, 其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。

你可能感兴趣的:(Java)