JAVASE_面向对象上

1. java的特性和优势：简单性，面向对象，可移植性，高性能，动态性，多线程，安全性和健壮性。
2. 什么是面向对象：把数据及对数据的操作方法放在一起，作为一个相互依存的整体。面向对象是对生活中事物的一种模型化处理，把事物的共性和行为抽取出来，形成其属性或方法，对其属性和方法进行封装就形成了一个类（模板）换句话说其实就是一种数据类型，只是此种数据类型是一个结构化的，随人的抽取方式不同可变化的罢了。而对象就是在此种数据类型，即类类型的基础上产生的，对象可以看做是一个类类型的变量。总而言之：类是人对事物的属性和行为抽取封装而来，而对象是类的实例。
3. 为什么要存在面向对象：为了解决实际问题，人们通常把问题相关的对象属性和行为抽取出来，舍弃其对问题的解决无关紧要的属性和行为，而抽取出来的这个模板对问题的求解带来了很大的方便性。

类的定义;
public class Perosn {
	String name;//抽取出人的共性：有名字
	int age;//有年龄
	String  sex;//
int long;//身高
//..
public Person(String name){
	this.name = name;
}	
public void eat{}//吃

public void speak{}//说话
	
 //...其他日常行为
}

• 对象的产生:

  Person p = new Person("张三");//创建一个对象，该人的名字叫张三

• 类中被static修饰的属性和方法专属于该类，调用的时候直接采用:类名.属性名 类名.方法来调用注意：static变量在类加载的时候就已经加载存在了，对象属性则不同。static变量随着类的加载而出现，随着类的消失而消失。静态方法只能访问静态成员（因为对象属性在类加载时并不存在）。
• private,protect,default,public定义的类的访问权限:private 定义的类只能出现在内部类中，protect定义的类访问范围在整个包中以及其子类访问，default定义的类只能在其包内被访问，而public定义的类在其整个项目中都是可见的。
  • 封装(private)的使用:

  1. private 私有，是一种权限修饰符。用于修饰的是类中的成员，私有的内容只能在本类中有效
  2. private 仅仅是封装的一种体现

     public class Perosn {
     	private String name;//每个人都有自己的名字，私有存在
     	private int age;//同上
     	private String  sex;//同上
     	//...
     	public String getName() {
     		return name;
     	}
     	public void setName(String name) {
     		this.name = name;
     	}
     	public int getAge() {
     		return age;
     	}
     	public void setAge(int age) {
     		this.age = age;
     	}
     	public String getSex() {
     		return sex;
     	}
     	public void setSex(String sex) {
     		this.sex = sex;
     	}
     }
     

     
     
  3. 构造函数：完成对象创建时的初始化的工作。需要注意的是：在构造函数完成某个字段的set功能时，此时应该要考虑该字段的set方法是否需要。其二是一般的方法不能直接调用构造函数，构造函数式用来对对象进行初始化的。最重要的一点：构造函数是有return语句的。//其实它默认返回的就是一个void
  4. 静态代码块：随着类的加载而执行，所以其运行的顺序在构造函数之前，用于给类进行初始化。

     package 面向对象;
     
     public class Test {
     
     		public static void main(String[] args){
     			Cat cat = new Cat("花猫");
     		}
     }
     
     class Cat{
     	static int maxAge = 0;
     	static{
     		maxAge = 10;
     		System.out.println("执行了static静态代码块");
     	}
     	public Cat(String name){
     		this . name = name;

  1. super的使用：super代表了父类空间，this代表的是本类对象的引用。

     package 面向对象;
     
     public class 继承 {
     
     		public static void main(String[] args){
     			Dog dog = new Dog(18 , "asd","男");
     			dog.say();
     		}
     }
     
     class Animal{
     	int age;
     	String sex;
     	
     	public Animal(int age , String sex){
     		this.age = age;
     		this.sex = sex;
     	}
     }
     
     class Dog extends Animal{
     
     	String name;
     	
     	public Dog(int age , String name , String sex){
     		super(age, sex);
     		this.name = name;
     	}
     	
     	public void say(){//若为给子类赋值，则jva会父类索要该属性的值
     		System.out.println(this.name+this.age+this.sex+super.age+super.sex);
     	}
     }
     结果：asd:18男18男

     
     
  2. 覆盖（override）和重载(overload)（也叫重写）：覆盖发生在父类和子类之间，子类重新定义了一个和父类同返回参数同名的函数，重载：发生在同一个类中，方法名和方法的返回的参数类型相同，但是其方法的参数类型不同

     package 面向对象;
     /**
      * 单例设计模式
      * @author Administrator
      *1.提供一个私有化的构造函数
      *2.创建对象的任务在本类中实现
      *3.定义一个public static方法将该对象返回
      */
     public class 单例设计模式 {
     
     		public static void main(String[] args){
     			SingleModel sm = SingleModel.Instance();
     			SingleModel sm2 = SingleModel.Instance();
     		}
     }
     
     class SingleModel{
     	static SingleModel sm= null;
     	private SingleModel(){}
     	
     	public static SingleModel Instance(){
     		if(sm == null){
     			System.out.println("创建了一个SingleModel对象");
     			return sm = new SingleModel();
     		}else{
     			return sm;
     		}
     	}
     }
     //运行结果:创建了一个SingleModel对象

  • 面向对象总结

  1. 面向对象强调的是对象实例，面向过程强调的是动作，对象是将对象进行封装
  2. 在问题的领域中我们解决问题都是先去找问题领域中所涉及到的对象，然后再去分析对象的属性和行为
  3. 面向对象的特点是：是一种常见的思想，复杂变简单，执行者变指挥者
  4. 类与对象的关系：类是对象的模板，对象是类的实例
  5. 封装：隐藏其细节，并对外提供其公共的接口：特点是,隔离变量，便于使用，提高复用性，提高安全性
  6. 覆盖：子类继承父类，父类方法不再满足子类的要而重写了何其方法名返回值类型和参数类型完全相同的函数