尚硅谷第五天课0722班 java-面向对象学习的三条主线-面向对象的思想概述- 类的元素- java类及类的成员-类的成员之方 法

面向对象学习的三条主线：
* 1.类和类的组成（属性（或成员变量）、方法、构造器；代码块（或初始化块）、内部类）
* 2.面向对象的特征：封装与隐藏、继承性、多态性、（抽象性）
* 3.其它关键字的使用：this super package static final abstract import interface ...
面向对象与面向过程
java语言的基本元素：类和对象
类的成员之一：属 性
类的成员之二：方 法
对象的创建和使用
再谈方法
面向对象特征之一：封装和隐藏
类的成员之三：构造器（构造方法）
几个关键字：this、package、import

1.	面向对象与面向过程
面向对象(OOP)与面向过程 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为。面向对象，将功能封装进对象，强调具备了功能的对象。 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。 面向对象的三大特征 封装  (Encapsulation) 继承  (Inheritance) 多态  (Polymorphism) OOP: Object Oriented Programming   面向过程：procedure oriented programming
面向对象的特点
答：面向对象有三大特点：封装、继承、多态。(如果要回答四个，可加上 抽象性 这一特点)
1.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
2.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
3. 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
4.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

例子：人把大象装冰箱
1.	打开冰箱
2.	把大象装进冰箱
3.	把冰箱门关住
人{
打开（冰箱）{
冰箱.开门();
}
操作(大象){
大象.进入();
}
关闭(冰箱){
冰箱.关门();
}
}
冰箱{
开门(){}  关门(){}
}

1.public void fun(){
private String ss="";
int i =ss.length();
}
局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。

2构造器Constructor是否可被override
答：构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload
2.	类与类之间的关系

关联关系 继承关系

面向对象的思想概述
程序员从执行者转化成了指挥者。 完成需求时： 先去找具有所需功能的对象来用。 如果该对象不存在，那么创建一个具有所需功能的对象。 这样简化开发并提高复用。 类(class)和对象(object)是面向对象的核心概念。 类是对一类事物描述，是抽象的、概念上的定义 对象是实际存在的该类事物的每个个体，因而也称实例(instance)。  “万事万物皆对象”

现实世界万事万物是由分子、原子构成的。同理，Java代码世界是由诸多个不同功能的类构成的。 现实世界中的分子、原子又是由什么构成的呢？原子核、电子！那么，Java中用类class来描述事物也是如此 属 性：对应类中的成员变量 行 为：对应类中的成员方法 Field = 属性 = 成员变量，Method =  (成员)方法 = 函数

可以理解为：类 = 汽车设计图；对象 = 实实在在的汽车 面向对象程序设计的重点是类的设计 定义类其实是定义类中的成员(成员变量和成员方法)
package note;
//面向对象的学习三条主线
/*
*关注与类的设计，设计类，实际就是设计成员变量，属性，方法
*面向对象的实现
*设计一个类的属性和方法
*创建这个类的对象也成为类的实例化
*通过类.属性，方法来调用类的结构
*
* 创建类的不同对象，相当于创建了拥有统一类性质的不同对象
*/
public class oop1 {
public static void main(String[] args) {
person p1 = new person();
p1.name="wangqi";
p1.eat();
p1.sleep();
}
}
class person{
//1.属性（或成员变量,Field）
String name;
int age;
boolean sex;
//2.方法（或函数，Method）
public void eat(){
System.out.println(name+"吃饭");
}
public void sleep(){
System.out.println(name+"睡觉");
}
public void show(){
System.out.println("name"+name+"age"+age+"sex"+sex);
}
public String getName(){
return name;
}
}

/*
* 类的元素
* 1.属性（成员变量 Field）
* 	成员变量 vs局部变量
* >相同点：声明的格式是类似的 数据类型 变量名 = 初始化值 作用域 都在其定义的作用{}
*
* >不同点：1.声明的位置不同 成员变量：声明在类的内部方法的外部 局部变量 方法内 参数的形参 代码块
* 		   局部变量前不能放置任何访问修饰符 (private，public，和protected)。
* 		  final可以用来修饰局部变量 final不叫权限修饰符
* 		  2.对于成员变量可以
* 		  3.对于成员变量，可以显式初始化，也可以默认初始化
* 			byte short int long =>0 float double =>0.0
* 			对于局部变量必须显式赋值
* 		  4在内存分布上不同 成员变量：存放在堆空间；局部变量：存放在栈空间
*  2方法（函数Meyhod）---封装了一定的功能
* 		<1. 如何定义一个类的方法 权限修饰符 返回值得类型 方法名（形参列表）{
* 				方法体；
* 				}
* 		public void eat(){}
* 		public void addAgg(int age){}
* 		public String display(){}
* 		>1）权限修饰符 private protected public
* 		>2)返回值类型  没有返回值 （方法声明出使用void） 有具体的返回值的类型 在方法体内指明返回值类型
* 		void 与return
* 		满足标识符的命名规范剑灵知意
* 		参数列表 局部变量 可以根据需要定义一个或者多个
* 		方法体 通过对象方法的形式进行调用
* 		方法可以通过“对象，方法”的形式进行调用
* 		方法内可以调用本类的其他属性和方法
* 		类的内部可以直接调用类内部的属性
* 		方法里 不能在定义方法
*
*/
*/
package note;
public class opp1zoo {
public static void main(String[] args) {
Animal a1 = new Animal();
a1.show();
a1.name = "Tom";
a1.age = 34;
a1.show();
}
}
class Animal{
//1.属性
String name;
int age;
//2.方法
public void eat(){
final int a=8 ;
System.out.println(a+name+"吃饭");
}
public void sleep(){
System.out.println(name+"睡觉");
}
public void show(){
System.out.println("name"+name+"age"+age);
}
}

1.       java类及类的成员

2.	类的成员构成 verson 2.0

王琪 15:49:00
老师类的属性就是成员变量吗？
宋红康老师 15:50:18
对。现在就可以不加区别的这么称谓

<p>1.       抽象出下面系统中的“类”及其关系。</p>

4.	创建Java自定义类
步骤： 定义类（考虑修饰符、类名） 编写类的属性（考虑修饰符、属性类型、属性名、初始化值） 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

练习： 定义Person、Animal、ClassRoom、Zoo等类，加以体会。
5.	类的成员之一：属性
语法格式： 修饰符  类型  属性名 =初值 ;  说明:修饰符private:该属性只能由该类的方法访问。 	        修饰符public:该属性可以被该类以外的方法访问。                         类型：任何基本类型，如int、boolean或任何类。 举例：      public class Person{            private int age;             //声明private变量 age            public String name = “Lila”;    //声明public变量 name       } 补：变量的分类：成员变量与局部变量
在方法体外，类体内声明的变量称为成员变量。 在方法体内部声明的变量称为局部变量。

注意：二者在初始化值方面的异同:          同：都有生命周期                异：局部变量除形参外，需显式初始化。
成员变量（属性）和局部变量的区别？ 成员变量： 成员变量定义在类中，在整个类中都可以被访问。 成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。 成员变量有默认初始化值。 成员变量的权限修饰符可以根据需要，选择任意一个  局部变量： 局部变量只定义在局部范围内，如：方法内，代码块内等。 局部变量存在于栈内存中。 作用的范围结束，变量空间会自动释放。 局部变量没有默认初始化值，每次必须显式初始化。 局部变量声明时不指定权限修饰符

类的成员之二：方  法
语法格式：  	修饰符  返回值类型  方法名 ( 参数列表) {   	 方法体语句； }  说明： 修饰符：public, private, protected等。 	返回值类型：return语句传递返回值。没有返回值：void。 举例： 	public class Person{     private int age;     public int getAge()  { return age; } //声明方法getAge     public void setAge(int i) {          //声明方法setAge 	  age = i;        //将参数i的值赋给类的成员变量age     } } 对象的创建和使用
使用new +构造器创建一个新的对象； 使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）；
举例:  public class Zoo{    public static void main(String args[]){ 	Animal xb=new Animal(); 	xb.legs=4; 	System.out.println(xb.legs); 	xb.eat(); 	xb.move();    } } public class Animal {   public int legs;	       public void  eat(){     System.out.println(“Eating.”);   }   public viod move(){       System.out.println(“Move.”);   } }

对象的创建和使用
如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。 举例:  public class Zoo{     public static void main(String args[]){ 	Animal xb=new Animal(); 	Animal xh=new Animal(); 	xb.legs=4; 	xh.legs=0; 	System.out.println(xb.legs);   //4 	System.out.println(xh.legs);   //0 	xb.legs=2; 	System.out.println(xb.legs);   //2 	System.out.println(xh.legs);   //0     }  }

/*
* 创建Person类的对象，
* 设置该对象的name、age和sex属性，
* 调用study方法，输出字符串“studying”，调用showAge()方法显示age值，
* 调用addAge()方法给对象的age属性值增加2岁。
*/
package note;
import java.util.Scanner;
public class code5opp {
public static void main(String[] args) {
System.out.println("输入题目号:1/2");
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
switch (a) {
case 1:
fun1();
break;
case 2:
fun2();
break;
default:
System.out.println("输入不对");
break;
}
scanner.close();
}

public static void fun1() {
System.out.println("第一题");
Person5 p1 = new Person5();
p1.study();
p1.showAge();
System.out.println("addage=" + p1.addAge());
Person5 p2 = new Person5();
p2.study();
p2.showAge();
System.out.println("addage=" + p2.addAge());

}

public static void fun2() {
Scanner s = new Scanner(System.in);
System.out.println("半径输入 /直径输入:(1/2)");
int a = s.nextInt();
if (a == 1) {
System.out.println("输入半径");
double r = s.nextDouble();
Circle area1 = new Circle(r);
System.out.println(area1);
}
if (a == 2) {
System.out.println("输入直径");
double r = s.nextDouble();
Circle area2 = new Circle(r, 'R');
System.out.println(area2);
}
s.close();
}
}

class Person5 {
private String name;
private int age;
private int sex;

public void study() {
System.out.println("study");
}

public void showAge() {
System.out.println("age=" + age);
}

public int addAge() {
this.age += 2;
return this.age;
}
}

class Circle {
double a;
double b;
double area;

public Circle(double a) {
area = Math.PI * a * a;
}

public Circle(double b, char r) {
area = Math.PI * (b / 2.0) * (b / 2.0);
}

public String toString() {
return "圆的面积：" + this.area + " ";
}
}
类的访问机制： 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）  在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。
对象的产生
lass Person{ 	int age; 	void shout(){ 		System.out.println(“oh,my god! I am ” + age); 	} } Person p1 = new Person();执行完后的内存状态

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面讲过的数组。  对象的使用
class TestPerson{ 	public static void main(String[] args) {   //程序运行的内存布局如下图  		Person p1 = new Person(); 		Person p2 =new Person(); 		p1.age = -30; 		p1.shout(); 		p2.shout(); 	} }

根据代码，画出内存图
class Car{        String color = "red";        int num = 4;        void show(){ 	    System.out.println("color="+color+"..num="+num);         }   } class TestCar { 	public static void main(String[] args) { 		Car c1 = new Car();   //建立对象c1 		Car c2 = new Car();   //建立对象c2 		c1.color = "blue";   //对对象的属性进行修改 		c1.show();   //使用对象的方法 		c2.show(); 	}  }

匿名对象
我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。 如：new Person().shout();   使用情况 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。  我们经常将匿名对象作为实参传递给一个方法调用。