抽象abstract

抽象类中包括抽象方法，不可以实例化

1.抽象类必须要有子类(内部可能已经提供了子类)

2.抽象类的子类必须覆写抽象类中的全部抽象方法（方法覆写一定要考虑到权限public）

3.抽象类的对象可以通过对象的多态性实现

 

对象的产生分析

引用类型指的是内存空间的操作。

 现在的内存分为两块内存空间：

堆内存空间：保存真正的数据，堆内存保存的是对象的属性信息；

栈内存空间：保存的堆内存的地址，堆内存操作权，保存的是对象名称；

一个栈内存中只能够保存一个堆内存地址。

对象的产生实际上会有两种格式：

声明实例格式

分布式格式

对象（所有的引用数据类型）必须在其开辟空间之后才可以使用。如果使用了未开辟内存空间的引用数据类型，则将出现NullPointerException

只声明对象，并没有为其开辟堆内存空间，而 程序在编译的时候不会产生任何的语法错误，但是在检测的时候会出现如下错误提示：Exception in thread "main"java. lang.NullPointerException at TestDemo.main(TestDemo.java:12)-数字代表代码行数

只有引用数据类型（数组、类、接口）才会产生此类异常，以后出现了可以根据错误的位置观察该对象是否实例化。

 

 

this

1.访问本类中的属性、方法

2.先查找本类，如果本类没有则调用父类

3.表示当前对象

super

1.由子类访问父类中的属性或者是方法

2.不查找本类而直接调用父类定义

重载

1.Overloading

2.方法名称相同，参数的类型及个数不同

3.发生在一个类之中

4.没有权限要求

覆写

1.Override

2.方法名称、返回值类型、参数的类型及个数完全相同

3.继承关系之中

4.被覆写的方法不能有比父类更高的访问使用权限

访问static属性直接通过类名称。

而非static属性必须通过实例化对象才能访问。

java中转义用"\\"两条斜线，而js中是一条斜线

import java.security.PublicKey;
import java.util.Date;

import javax.naming.directory.SearchControls;

import org.omg.CORBA.PRIVATE_MEMBER;






interface Pet{
	public String getName();
	public String getColor();
	public int getAge();
	
}

class Link{
    private class Node{
    	private Object data;//保存节点数据
    	private Node next;//保存节点关系
    	
        public Node (Object data) {
			this.data = data;
			
		}
        //第一次调用：this = Link.root
        //第二次调用：this = Link.root.next
        public void addNode(Node newNode){//处理节点关系
        	if(this.next == null){//当前节点下一个为空，表示可以保存
        		this.next = newNode;
        	}else{//现在当前的节点有数据，取下一个
        		this.next.addNode(newNode);//递归操作
        	}
        }
        public void toArrayNode() {
			Link.this.retData[Link.this.foot++] = this.data;//数据丢数组，脚标加1
			if (this.next!=null) {
				this.next.toArrayNode();
			}
			
		}
        public boolean containNode(Object search){
        	if (search.equals(this.data)) {//找到了
				return true;
			}else {
				if (this.next!=null){
				return this.next.containNode(search);
				}else{
					return false;
				}
				}
        }
        public Object getNode(int index){
        	if (Link.this.foot++ == index) {
        		
        		return this.data;
				
			}else {
				System.out.println("=");
				this.next.getNode(index);
			}
        	return null;
        }
        public void setNode(int index,Object newData){
        	if (Link.this.foot ++ == index) {
				this.data = newData;
				return;
			}else {
				if(this.next != null){
					this.next.setNode(index, newData);
				
				}
			}
        }   
        public void removeNode(Node previos,Object data) {
			//第一次调用：Link.root.next;
        	if (this.data.equals(data)) {//当前节点为删除节点
				previos.next = this.next;
				System.out.println("删除成功啦");//删除当前，对象失去引用，GC处理
			}else {
				this.next.removeNode(this,data);
			}
        	 
		}
    }
    //--------------以下为Link类定义-------------
    private Node root;//定义根节点
    private int count = 0;//保存计数 ，当前的保存个数
    private Object[] retData; 
	private int foot = 0;
    public void add(Object data){
    	if (data == null) {
			return;
		}
    Node newNode = new Node(data);
    if(this.root == null){
    	this.root = newNode;
    }else{//根节点已经存在
    	//应该把此时的节点顺序的处理交给Node类
    	this.root.addNode(newNode);
    	
    }
    this.count++;
}
    public int size(){
    	return this.count;
    }
    public boolean isEmpty(){
    	return this.root==null;
    }
    public Object[] toArray(){//转换成为数组的方法
    	if (this.count == 0 ) {//链表为空，返回null
			return null;
		}
    	this.retData = new Object[this.count];//创建数组retData用来装数据
    	this.foot=0;//脚标赋初始值0
    	this.root.toArrayNode();//数据的顺序交给Node处理
    	return this.retData;
    }
    public boolean contains(Object search){
    	if(search == null || this.root == null){
    		return false;
    	}
    	return this.root.containNode(search);
    }
    public Object get(int index){
    	if(index >= this.count){
    		return null;
    	}
    	this.foot = 0;
    	return this.root.getNode(index);
    }
    public void set(int index,Object newData){
    	if(index>=this.count){//超过了保存的个数
    		return; //结束
    	}
    	this.foot=0;
    	this.root.setNode(index,newData);
    }
    public void remove(Object data){
    	if(this.contains(data)){//如果存在则删除处理
    		if(this.root.data.equals(data)){//先判断是不是根节点
    			this.root = this.root.next;//根节点变为下个节点
    		}else {//不是根节点则
				this.root.next.removeNode(this.root,data);
			}
    		this.count --;
    		System.out.println("删除成功");
    	}
    }
}
/*
 * 猫
 */
class Cat implements Pet{
	private String name;
	private String color;
	private int age;
	
	
	
	public String getName() {
		return name;
	}



	public void setName(String name) {
		this.name = name;
	}



	public String getColor() {
		return color;
	}



	public void setColor(String color) {
		this.color = color;
	}



	public int getAge() {
		return age;
	}



	public void setAge(int age) {
		this.age = age;
	}



	public Cat(String name,int age,String color){
		this.name = name;
		this.age = age;
		this.color = color;
	}
	public boolean equals(Object obj){
		if (obj == null) {
			return false;
		}
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof Cat)) {
			return false;
		}
		Cat pet = (Cat) obj;
		return this.name.equals(pet.name)&&this.age ==  pet.age&&this.color.equals(pet.color);
	}
	public String toString(){
		return "【猫】名字："+this.name+" 年龄："+this.age+" 颜色："+this.color;

	}
}
/*
 * 狗
 */
class Dog implements Pet{
	private String name;
	private String color;
	private int age;
	
	
	
	public String getName() {
		return name;
	}



	public void setName(String name) {
		this.name = name;
	}



	public String getColor() {
		return color;
	}



	public void setColor(String color) {
		this.color = color;
	}



	public int getAge() {
		return age;
	}



	public void setAge(int age) {
		this.age = age;
	}



	public Dog(String name,int age,String color){
		this.name = name;
		this.age = age;
		this.color = color;
	}
	public boolean equals(Object obj){
		if (obj == null) {
			return false;
		}
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof Dog)) {
			return false;
		}
		Dog pet = (Dog) obj;
		return this.name.equals(pet.name)&&this.age ==  pet.age&&this.color.equals(pet.color);
	}
	public String toString(){
		return "【狗】名字："+this.name+" 年龄："+this.age+" 颜色："+this.color;

	}
}
/*
 * 宠物店
 */
class PetShop{
	private Link pets = new Link();
	public void add(Pet pet){
		this.pets.add(pet);
	}
	public void delete(Pet pet){
		this.pets.remove(pet);
	}
	public Link getPets(){
		return this.pets;
	}
	public Link Search(String keyword){
		Link result = new Link();
		Object [] data = this.pets.toArray();
		for (int i = 0; i < data.length; i++) {
			Pet pet = (Pet) data[i];
			if (pet.getName().contains(keyword) || pet.getColor().contains(keyword)) {
				result.add(pet);
			}
			
		}return result;
	}
}
public class PetStore {
	public static void main(String[] args) {
		PetShop ps = new PetShop();
		ps.add(new Dog("黑狗", 1, "黑色"));
		ps.add(new Dog("金毛", 3, "金色"));
		ps.add(new Dog("泰迪", 2, "棕色"));
		ps.add(new Dog("腊肠", 2, "灰色"));
		ps.add(new Cat("加菲猫", 1, "金色"));
		ps.add(new Cat("加菲猫", 1, "金色"));
		ps.delete(new Dog("金毛", 3, "金色"));
		Link all = ps.Search("金");
		Object [] data = all.toArray();
		for (int i = 0; i < data.length; i++) {
			System.out.println(data[i]);
		}
		}
	}

 

类定义：

1.声明并实例化对象：类名称 对象名称=new 类名称（）;

2.分步进行对象实例化：

(1)声明对象：类名称  对象名称=null;

(2)实例化对象：对象名称=new 类名称();

调用类中的属性：对象.属性=内容;

调用类中的方法：对象.方法();

private int age;

public void setAge(int n){

 if(n>=0&&n<=150){

   age=n;

}else{

  age=0;

}

}

public int getAge(){

 return age;

}

类的设计原则：

类中的所有属性必须使用private封装

private只允许本类访问，而不允许外部访问。

String的拆分：

  str.split("\\.",2);

 

对象内存分析
1. new表示开辟新的内存空间

2.两个内存空间
    堆内存空间：保存真正的数据，保存的是对象的属性信息
    栈内存空间：保存的堆内存的地址，堆内存操作权，保存的是对象的名称

3.引用的本质是别名，只不过这个别名放在了另一个栈内存之中，即一个堆内存可以被多个栈内存所指向

4.垃圾内存空间指的是没有任何栈内存指向的堆内存空间，所有的垃圾空间将不定期被Java中的垃圾收集器（GC，Garbage Collector）进行回收以实现内存空间的释放，不过从实际开发来讲，虽然java提供有gc,但gc也会造成程序性能的下降，所以开发过程中一定要控制好对象的产生数量，即无用的对象应尽量少产生。

5.匿名对象不会有任何的栈空间所指向，所以使用一次后变成为垃圾空间
    匿名对象：Person("Mike",20).info()

Java类开发要求
1.类名称必须明确的描述出某一类事务，如Member、Dog

2.类的属性必须用private封装，所有的属性必须按照要求提供有setter、getter方法

3.类中可以定义多个构造方法，但必须保留一个无参构造方法

4.类中的所有方法都不允许出现任何的System.out语句，所有的输出必须交给调用处完成

5.类中应该提供有一个返回类完整信息的方法，这个方法名称暂时为getInfo()

 

从一个完整的字符串中判定制定的内容是否存在

public boolean contains(CharSequence s)判断一个子字符串是否存在

public int indexOF(String str)从头开始查找指定字符串的位置，查到了返回位置的开始索引，如果查不到返回-1

public int indexOF(String str,int fromIndex)从指定位置开始查找子字符串的位置

public int lastInDexOF(String str)由后向前查找子字符串的位置

public int lastIndexOF(String str,int formIndex)从指定位置由后向前查找子字符串位置、

public boolean startWith(String prefix)从头判断是否以指定的字符串开头

public boolean startsWith(String prefix,int toffset)从指定位置开始判断是否以指定字符串开头

public boolean endsWith(String suffix)判断是否以指定的字符串结尾

1、类本身属于引用类型，所以类的使用上会牵扯到内存的分配问题。

2、所谓的类描述的就是共性的特征。任何时候只是依靠共性的特征是无法进行精准描述的，那么就需要一些个性化得特点。就可以描述一个个独立的事物。所以这样我们就可以推断出：所谓的类指的就是一个共性的概念，而对象指的是一个具体的可以使用的事物。

3、那么很明显在实际的开发过程中一定需要产生类，而后才可以产生对象。那么对象的所以操作行为都一定在类中进行了完整定义。类中没有定义的功能，那么对象一定无法使用。

类中的组成：方法（操作的行为）、属性（变量，描述每一个对象的特点）

 

1、面向对象是一种程序的设计方法，但是并不表示世界所有的开发者都认同面向对象。因为有很多的开发者认为面向对象过于复杂，所以更多的人愿意使用函数式编程。

2、面向对象的前身属于面向过程，如果想要笼统的解释这两者开发模型的区别，最好的例子：面向过程是解决问题，而面向对象是模块化设计。

面向过程只是解决当前的需求问题、特定的问题，它不能解决需求化。

自己根据自己的需求造的车，别人无法帮你修。

 

对于我们现在的程序开发更多情况下就像是汽车组装一样，不同的工厂生产不同的配件。将所有的零件组装在一起，就可以形成一辆汽车，并且当我们的一个零件坏掉的时候还可以进行配装。

面向过程缺少了这种可重复性设计，而面向对象具备了这种可重复性设计。

 

面向对象的操作特点：

1、封装性：内部的操作对外部而言不可见；做保护。

2、继承性：在上一辈的基础上进一步发展；（不能每一代人从猴再开始发展吧，一代比一代聪明）

3、多态性:这是一个最为重要的环节，利用多态性才可以得到良好的设计。它是一个在可控范围内的状态改变。

一旦有了继承性就有了重用型设计。

一旦有了多态性你就会得到一个更好的设计方案。

 

那么在进行面向对象开发的时候有三个阶段：OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。

所有的程序开发原则都离不开实际生活。如果从程序的开发角度来讲，面向对象给我们最大的一个特征：可以进行生活的抽象。

在整个java里面，我们不能只考虑面向对象本身，还应该更多的考虑是它的内存的分配问题，这个才是核心所在。

 

getNode 代码错误

应该是

if

...

else

return this.next.getNode(index)

被覆写的方法不能拥有比父类更严格的访问权限。

子类对象在实例化前一定会先实例化父类对象 子类构造函数里面采用super()语句实例化父类对象 super（）在无参时可写可不写。 有参构造：有参构造一旦出现，默认的无参构造将不会出现。 父类的构造函数是有参构造时，子类的构造函数里的super(), 括号类需要明确指定调用父类的有参构造。 Java只允许单继承，不允许多重继承。允许多层继承。 一般最多三层。 （C++允许多继承。） Java子类会继承父类的所有结构：包括私有属性，构造方法 普通方法，共有属性。 所有的非私有操作属于显式继承：可以直接调用， 所有的私有操作属于隐式继承：通过其他形式调用。（通过父类public 方法访问private 成员变量） 所有的private操作无法直接使用，所以称为隐式继承。

JDK1.7及以前，方法中的内部类要 访问方法的形式参数，需要在形式参数 前面，加final。JDK1.8及以后的版本，可 不加。 内部类 ： 破坏了程序的结构 方便进行私有属性的访问（通过类对象） 类名称上出现了“. ”,首先想到static 类。

class Outer{ private String meg="Hello World !"; static class Inner{ public void print() { System.out.println(msg) ;//error 只能使用外部类中的static操作 } } } 正确的代码： class Outer{ private static String meg="Hello World !"; static class Inner{ public void print() { System.out.println(msg) ;// } } static变量（类变量）随着类的加载而存在。 成员变量（实例变量）随着对象的创建而存在。