01-java学习笔记01

1.面向对象

 

面向对象：三个特征：封装， 继承， 多态

 

类和对象的关系

 

类就是：对现实生活中的事物的描述。

对象：就是这类事物，实实在在存在个体。

 

class Car
{
     String color = "黄色";
     int num = 4;
 
     void run()
     {
          System.out.println( color+ ".."+num );
     }
}
 
public class CarDemo
{
     public static void main(String[] args)
     {
          Car c = new Car();
          c.run();
     }
}

 

堆和堆栈

1.堆栈。java系统必须知道存储在堆栈内的所有项的确切生命周期，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些Java数据存储于堆栈中——特别是对象引用，但是java对象并不存储于其中。

2.堆。一种通用的内存池，用于存放所有的Java对象。堆不同于堆栈的好处是：编译器不需要知道存储的数据在堆里存活多长时间。因此在堆里分配存储有很大灵活性。当需要一个对象时，只需用new写一行简单的代码，当执行这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性要付出相应的代价：用堆进行存储分配和清理可能比用堆栈进行存储分配需要更多的时间（如果在java中可以像C++中一样在栈中创建对象）。

 

2.成员变量和局部变量

 

1）作用范围不一样

 

成员变量作用于整个类中，

局部变量作用于函数中，或者语句中。

2) 在内存中的位置

成员变量在堆内存中，因为对象的建立才存在。

局部变量位于堆栈中。

 

3.匿名对象的应用

 

new Car();//匿名对象
 
Car c = new Car();
c.num = 5;
 
 
new Car().num = 5;
new Car().color = "blue" ;

//匿名对象调用属性没有意义

//匿名对象调用方法有意义

 

//匿名对象使用方式一：当对对象只调用一次时，可以用匿名对象来完成，这样写比较简化。

//如果对一个对象进行多个成员调用，必须给这个对象起个名字。

 

//匿名对象使用方式二：可以将匿名对象作为实际参数进行传递

 

main()
{
     //Car c = new Car ();
     //show(c);
     show(new Car());   //?强引用 软引用 弱引用 虚引用?
}
public static void show(Car c)
{
     c.num = 5;
     c.color = "yellow";
     c.run();
}

 

4.封装 (Encapsulation)

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

     将变化隔离。

     便于使用。

     提高重用性。

     提高安全性。

封装原则：

     将不需要对外提供的内容都隐藏起来。

     把属性都隐藏，提供公共方法对其访问。

 

private ：私有，权限修饰符：用于修饰类中的成员（成员变量, 成员函数）。

将age私有化以后，类以外即使建立了对象也不能直接访问。

但是人应该有年龄，就需要在Person类中提供对应访问age的方式。

 

注意：私有仅仅是封装的一种表现形式。

 

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。

public class PersonDemo {
        public static void main(String[] args)
       {
              Person P = new Person();
              
               P.setAge(20);
               P.setAge(-20);
               P.setAge(140);
       }
}
 
class Person{
        private int age ;
       
        public void setAge(int a)
       {
               if(a <0||a >130)
                     System. out.println("error" );
               else
              {
                      age = a;
                     speak();
              }
                     
       }
       
        public int getAge()
       {
               return age ;
       }
        void speak()
       {
              System. out.println("age=" + age );
       }
}
 

5.构造函数

特点：

1.函数名与类名相同

2.不用定义返回值类型

3.不可以写return语句

作用：
1.默认构造函数的特点

 

 

对象一建立就会调用与之对应的构造函数

构造函数的作用：可以用于给对象进行初始化

 

当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数（Person(){}）

当定义了构造函数时，默认的构造函数就没有了。

 

构造函数与一般函数在写法上有不，同。

在运行上也有不同。

构造函数在对象一建立就运行。给对象初始化。

而一般方法是对象调用才执行，给对象添加对象具备的功能

 

一个对象建立，构造函数只运行一次

而一般方法可以被该对象调用多次

 

什么时候定义构造函数？

当分析事物时，该事物存在就具备一些特性或者行为，那么将这些内容定义在构造函数中。

 

class Person2
{
        private String name ;
        private int age ;
        //Person(){}
       Person2()
       {
            System. out.println("A: name" +name +"...age=" +age );
       }
       Person2(String n)
       {
            name = n;
            System. out.println("A: name" +name +"...age=" +age );;
       }
       Person2(String n, int a )
       {
            name = n;
            age = a;
            System. out.println("A: name" +name +"...age=" +age );;
       }
}
 
class PersonDemo2
{
     public static void main(String[] args)
     {
          Person2 p = new Person2 ();
          Person2 p1 = new Person2( "mike");
          Person2 p2 = new Person2( "mike2",99);
     }
}

 

6.构造代码块

 

作用：给对象进行初始化

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

     给所有对象进行统一初始化

而构造函数是给对应的对象进行初始化

构造代码块中定义的是不同对象共性的初始化内容

 

class Person
{     
     {
          System.out.printf(Person run);
     }
     private int age ;
}

 

7.this关键字

 

将参数与数据成员区分

 

 

this语句：用于构造函数之间进行相互调用。

只能调用一个

且只能定义在构造函数的最起始处

在构造器中调用构造器