java基础部分

------  android培训 、 java培训 ，期待与您交流 ------
黑马程序员 java基础部分
1.面向对象的思想：

面向对象是基于面向过程的，将功能封装进对象，由对象条用，能让复杂事情简单化，能让我们的角色从执行者变为指挥者。就像打仗，将军有具体的作战方式，具体细节，如怎么布阵，哪里设埋伏等，而军师诸葛亮运筹帷幄，哪里需要攻，哪里需要守，什么时候追，什么时候退，只需传达命令给将军，不必事事躬亲。

面向对象的特征：面向对象的编程语言有封装、继承 、多态等3个主要的特征。
1.1继承：在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类的内容作为自己的内容，并可以加入若干新的内容，这就是继承。
继承的好处：提高了代码的复用性和可扩展性，让类与类之间产生了关系。有了这个关系，才有了多态的特性，因此继承为多态提供了前提。
子父类变量的特点：如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this，子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致，this代表的是本类对象的引用，super代表的是父类对象的引用。
继承中子父类构造函数的特点：
子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super(); 
如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
子父类方法的覆盖：
当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类的该函数，父类函数不会运行
如同父类的函数被覆盖一样，这种情况是函数的覆盖特性。
当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一样时，
子类需要重新定义该功能的具体内容。
覆盖注意事项：
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
静态只能覆盖静态。
1.2封装：
隐藏对象的属性和功能的实现细节，对位提供公共的访问方式，也就是说，在我们使用对象时，没必要知道对象内部是如何完成功能操作的好处在于将变化隔离，便于使用，提高重用性，提高了健壮性及安全性。
例如，正如张老师所讲，人要在黑板上画圆，这一共涉及三个对象：人、黑板、圆，由于画圆需要使用到圆心和半径，
圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，
它才能访问到圆心和半径这两个属性，人以后只是调用圆的画圆方法，所谓人画圆，其实只是给圆发给消息而已，
这就是面向对象的封装性，即将对象封装成一个高度自治和相对封闭的个体，对象属性由这个对象自己的方法来读取和改变。
成员变量我们可用修饰符private来进行封装，这样外界就不能直接获取该属性信息，

而提供具有逻辑的方法来进行对属性的访问，赋值或修改

package encapsulation;
public class Person {
//private缩小访问权限，是封装的一种体现形式
private int age;
private String name;
//提供公有方法，加入逻辑判断语句,提高代码健壮性

public void setAge(int age) {

if(age>0&&age<150){
this.age = age;
}
}
public void setName(String name) {
this.name= name;
}
}

1.3多态：

多态：可以理解为事物存在的多种体现形态。

动物：猫，狗。

猫 x = new 猫();
动物 x = new 猫();
1.3.1多态的体现：父类或者接口的引用指向了自己的子类对象。
1.3.2，多态的前提：必须是类与类之间有关系。要么继承，要么实现。
1.3.3，多态的好处：多态的出现大大的提高程序的扩展性。
1.3.4，多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，
不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)，若想要使用子类的特有功能时，

需要将父类的引用强制转向子类类型，即向下转型。

多态在子父类中的成员(非静态)上的体现的特点：
成员变量：在多态中，子父类成员变量同名。
在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）
运行时期：也是参考引用型变量所属的类中是否有调用的成员。
简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。
成员函数：
编译时期：参考引用型变量所属的类中是否有调用的方法。
运行事情：参考的是对象所属的类中是否有调用的方法。

因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

2.1抽象：抽象，就是笼统的模糊的，不具体的意思。当多个类中有相同的功能，但是功能的具体执行不同，向上抽取，这时仅保留功能定义，去掉功能主体。
抽象类的特点：
抽象方法用abstract关键字修饰，含有抽象方法的类也要用abstract修饰，抽象类不能用new关键字创建对象。
抽象类中的抽象方法需要由子类先实现所有的抽象方法(不实现所有抽象方法，这时子类还是抽象类)再创建子类对象进行调用。
抽象的应用，模板方法设计模式：
模板设计模式是指一段程序中某一处运行的部分是不确定的，那么就将其封装为一个方法提供出去，有子类实现具体的方法内容
这个部分必须由子类完成，因此将其设计为抽象的方法。
如获取一段代码的运行时间的设计：
package template;
public abstract class GetTime {
public final long getTime(){//该功能如不想被复写，用final限定
long start = System.currentTimeMillis();
//该方法具体要运行的代码不确定
//将其暴露出去，设计成抽象，由子类完成
runcode();
long end= System.currentTimeMillis();
return end = start;
}
public  abstract  void runcode();
}
3.1接口：
在java程序中，接口其中的方法全是抽象的，就是只有方法没有执行体。
接口提供一种途径，使类隐藏其处理的特定事物的细节，仅对外公布它必须支持的属性。
接口可用于功能的扩展，当实现了某一接口时，必须复写其中的抽象方法。
在java中，并不支持多继承，因为会有安全隐患，接口的出现将多继承通过多实现体现出来。
接口的格式： interface{}
接口中的成员修饰符是固定的：
成员变量：public static final
成员方法：public static abstract
interface Inter{
public static final int x = 3;
public abstract void show();
}
4.1内部类：
顾名思义，在一个类的成员位置上定义了一个类，这个定义在里面的类就是内部类。
如果A类需要直接访问B类中的成员，而B类又需要建立A类的对象，这时,为了方便设计和访问，直接将A类定义在B类中，就可以了。
内部类可以直接访问外部类中的成员，而外部类想要访问内部类，需要建立内部类的对象。
class Outer{
int num = 4;
class  Inner {
void show(){
System.out.println("inner show run "+num);
}
}
public void method(){
Inner in = new Inner();//创建内部类的对象。
in.show();//调用内部类的方法。 
}
}
当内部类定义在外部类中的成员位置上，可以使用一些成员修饰符修饰 private、static。
4.1.1：默认修饰符：
直接访问内部类格式：外部类名.内部类名 变量名 =  外部类对象.内部类对象;
Outer.Inner in = new Outer.new Inner();
4.1.2：私有修饰符：
通常内部类被封装，都会被私有化，因为封装性不让其他程序直接访问。
4.1.3：静态修饰符：
如果内部类被静态修饰，成为静态内部类，相对于外部类，会出现访问局限性，只能访问外部类中的静态成员。
注意；如果内部类中定义了静态成员，那么该内部类必须是静态的。
内部类可以直接访问外部类中的成员，那是因为内部中都持有一个外部类的引用。这个是引用是 外部类名.this 
当内部类被定义在局部位置上，只能访问局部中被final修饰的局部变量。
4.2内部类之匿名内部类：
匿名内部类在后面用的很多，是名字的内部类，是内部类的简化形式，一般只用一次就可以用这种形式。
匿名内部类其实就是一个匿名子类对象。
想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。
匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。
匿名内部类的使用场景：
当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。
package anonymous;
//定义一个抽象类，这个类将作为内部类的父类
abstract class AbsDemo{
public abstract void show();
}
class Outer {
int x=5;
//1.0内部类继承了一个抽象类
class Inner extends AbsDemo{
//2.0复写抽象方法
@Override
public void show() {
System.out.println(x);
}
}
public void function(){
//3.0建立内部类对象，
Inner in= new Inner();
 //4.0调用内部类方法
in.show();
}
}
将上面的1 2 3 4四不用匿名内部类一步完成：
package anonymous;
//定义一个抽象类，这个类将作为内部类的父类
abstract class AbsDemo{
public abstract void show();
}
  class Outer {
int x=5;
public void function(){
//new 父类或者接口，定义子类的内容，这样实际上是一个子类对象，然后调用方法
new AbsDemo() {
@Override
public void show() {
System.out.println(x);
}
         }.show();
}
}
------  android培训 、 java培训 ，期待与您交流 ------