Java(2)

面向对象的编程：以一种组件化的形式进行代码设计。
特点： （1）封装性  将函数进行封装，仅留下函数的接口，方便使用。
（2）继承性  在已有的程序结构上，扩充新的功能
（3）多态性   所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定。
类与对象：
类是共性特征（属性）的集合，而对象是类特例的产物。
对象所能操作的行为不可以超过类所定义的行为，类不可以直接操作，而实例对象是可以直接操作的。对象是通过类来产生的。




类（引用数据类型）的定义：
class Book {//类的定义
String title;
double price;
public void get(){
System.out.println(title+" price " +price);
}
}
定义完类之后，不可进行操作，必须进行实例化（即对象）才可以操作。




对象的定义方法：
·初始并实例化 类名称 对象名称=new 类名称();
·分不进行 类名称 对象名称=null;    对象名称=new 类名称();


new 是用来分配内存，只要是引用数据类型，都要通过new来进行内存的分配。




对象的定义:
public static void main(String args[]){
Book bd=new Book();//（实例化对象）
bd.title ="java";//不设置会出现默认值
bd.price=2.2;
bd.get();
}




内存分析：
堆内存与栈内存：
堆内存用来保存对象的所有属性和方法。
而栈内存用来保存对象的地址。使用时通过地址来改变堆内存中的数据。


类未进行实例化时，编译没有错误，但在运行时会出现错误：NullPointerException（空指向）。（引用数据类型都可能该问题）


对象引用类型的使用：
public class  project_1{//主类

public static void main(String args[]){
Book be=new Book();
Book bd=be;//引用类型;
bd.title ="java";
bd.price=2.2;
be.get();
be.get();
}
}


class Book {//类的定义
String title;
double price;
public void get(){
System.out.println(title+" price " +price);
}
}

一个堆内存可以被对个栈内存指向，但栈内存只可以指向一个堆内存。


第二种引用：
public class  project_1{//主类

public static void main(String args[]){
Book be=new Book();
Book bd=new Book();//引用类型;
bd.title ="java";
bd.price=2.2;
be.title="JS";
be.price=22;
bd=be;//经过此步后，bd，be指向的都是be对象，bd对象的指针丢失了。其对应的空间就被回收了。（自动的将垃圾回收）
be.get();
bd.get();
}
}


class Book {//类的定义
String title;
double price;
public void get(){
System.err.println(title+" price " +price);
}
}

封装性：
public class  project_1{//主类

public static void main(String args[]){
Book bd=new Book();//引用类型;
bd.title ="java";
bd.price=2.2;
bd.get();
}
}


class Book {//类的定义
private String title;//private 私有，用于封装
private double price;
public void get(){
System.err.println(title+" price " +price);
}
}
外部无法访问内部的private属性，所以会出现错误。


private属性可以通过内部函数来访问：
public class  project_1{//主类

public static void main(String args[]){
Book bd=new Book();//引用类型;
bd.change("java",2.2);
bd.get(); }
}


class Book {//类的定义
private String title;
private double price;
public void get(){
System.err.println(title+" price " +price);
}
public void change(String name,double money){
this.title=name;
this.price=money;
}
}


在类中用private定义的属性，需要定义相对应的函数来设置访问。


构造方法和匿名对象：
1 类名称 2 对象名称 = 3 new 4 类名称()


1.规定了对象的类型
2.对象名称
3.new开辟新的内存空间
4.调用构造函数（调用默认的构造函数）
定义构造函数：


public class  project_1{//主类

public static void main(String args[]){
Book bd=new Book("doudou",20);//引用类型;
//bd.change("java",2.2);
bd.get();
}
}


class Book {//类的定义
private String title;
private double price;

public Book(String name,int money){
this.title=name;
this.price=money;
}
public void get(){
System.err.println(title+" price " +price);
}
public void change(String name,double money){
this.title=name;
this.price=money;
}
}


构造方法：在申请堆空间时，默认调用。普通方法在实例化对象后可以多次调用。
构造方法是用来初始化属性设置的，用来设置属性的初始值。
构造方法可以重载：可以根据参数的不同来进行重载。


对象在进行构造时，一般会经过类的加载，内存的分配，构造函数，等一系列过程，构造函数是对象构造的最后一步，也是用户唯一可以处理的一步。
默认构造值，只有在构造函数执行完之后才可以设置为默认的构造值，在未完成之前一直对应其类型的默认值。




匿名对象：即没有引用的对象（没有名称的对象）。
匿名对象没有引用，因此只能使用一次。




简单Java类：
·类名称必须有意义
·类之中的所有属性必须用private封装，且要提供访问的函数。
·类中可以有多个构造函数，但必须包含有无参构造函数。
·类中不允许出现任何输出语句，所有信息输出必须通过被调对象
·类中必须包含有一个取的完整信息的方法，为getInfo(),而且返回String型数据。