脚本宝典收集整理的这篇文章主要介绍了12.11，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。
封装
继承
多态
Public:任何位置
Default: package 包级别，即同一个包下可以访问.
每个属性都可以生成对应的两个方法setter/getter;
Setter用来赋值;
Getter是用来取值的。
package day008;
/**
* 对信息封装"； 1.属性私有化,外部不能直接访问，但是为了我们的程序运行，用2步 2.提供”公共“的方法来访问私有的属性。
* 3.可以在方法中加入一些判断
*
* @author admin
*
*/
public class Person {
// 表示这个name是私有化
private String name;
private int age;
/**
* 提供公共的方法来访问私有属性： 给属性进行赋值
*
* @param name
*/
public void setName(String name) {
if(name == null)
{
name ="默认值";
}
this.name = name;
}
/**
* 公共方法的功能是访问私有的属性，获取私有属性的值并返回
*
* @return
*/
public String getName() {
return this.name;
}
}
package day008;
public class TestPerson {
public static void main(String[] args) {
Person p = new Person();
p.setName(null);
System.out.println(p.getName());
}
}
创建一个班级类，班级类中的属性分别为编号，名称，简介；
使用封装的思想，为这个类属性提供公共的访问方法；
创建测试类，创建班级类对象，对属性进行赋值，输出属性的信息。
toString ？自己决定
如果有两个类A 类B，满足 A[Dog] 是B[Animal] 的关系，我们就可以说 A 继承了 B，或者A 扩展 B，
Super(参数)；而且，这个super语句必须出现在子类构造的第一行.
创建一个老师类[父类];老师类老师名字;包含了一个上课的方法;
Java老师[子类]继承老师;
C#老师[子类]继承老师;
创建测试类，实例化Java老师对象;C#老师对象，调用父类老师的方法.
super关键字:
super关键字用在子类中;
可以用在子类的构造方法中;调用父类的构造方法 super(); 必须是子类构造中个第一行代码;
放在子类的普通方法中，可以调用父类的公共的方法: super.父类方法名();
我们希望子类中的方法依然和父类方法的声明形式一样，但是具体方法体却不同，这种做法就叫做方法覆盖。也称为方法的重写。
package com.exts;
public class Animal {
String name="animal~";
String type="animal type~!";
public void t() {
System.out.println("animal的普通方法");
}
public void t2() {
System.out.println("animal的普通方法t2");
}
}
package com.exts;
public class Pig extends Animal{
String color;
String name="Pig~";
@Override
public void t() {
System.out.println("Pig 普通方法 t方法,@override");
}
public void t3() {
System.out.println("Pig的普通方法T3");
}
}
package com.exts;
public class TestAnimal {
public static void main(String[] args) {
// Animal类引用 指向是 Animal的对象
// 引用 = new 类型();
//父类引用 指向 父类对象
//通过引用调用的属性和方法都是和父类相关的.
Animal animal = new Animal();
System.out.println(animal.name);
animal.t();
System.out.println("*****************");
//子类引用 指向 子类对象
//此时子类中定义了name t() 所以调用此时都是子类的属性和方法
//子类有，就调用子类的
Pig p = new Pig();
System.out.println(p.name);
p.t();
//"子类没有"，在访问修饰符允许的范围(能引用到),就调用父类的属性
System.out.println(p.type);
p.t2();//调用父类的方法
System.out.println("*****************");
//父类引用 指向 子类对象(向上转型)
Animal apig = new Pig();
//此时属性的值，都是"父类"中属性定义的值(不管子类中是否有同名的属性);
System.out.println(apig.name);
System.out.println(apig.type);
//方法
//Pig 普通方法 t方法,@override
//由于子类中队t方法进行了重写，所以此时调用的是子类中的方法
apig.t();
//父类有，子类没有重写 ;这个t2只有在父类中有定义，只能是父类的方法
apig.t2();
System.out.println("*****************");
//子类 引用 指向 父类对象(这种情况下，不可行)
// java.lang.ClassCastException:
//com.exts.Animal cannot be cast to com.exts.Pig
//不能直接"硬转"
Pig pAnimal = (Pig)new Animal();
}
}
Java中多态性指允许不同类的对象对同一消息(同一个方法)做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式
发送消息就是方法调用
现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在IE界面下弹出的浏览器的帮助文档；如果当前在 Word 下弹出的就是 office帮助；在 Windows 下弹出的就是 Windows 帮助和支持
可见，同一个事件发生在不同的对象上会产生不同的结果，因此，多态的主要作用适用于消除类型之间的耦合关系。
编译时多态：主要是方法的重载，通过参数列表的不同来区分不同的方法。
在程序编译期间，
根据参数列表不同，来决定最终绑定哪个方法进行调用的操作也称为重载；编译器完成判断。
运行时多态【继承和接口】：也叫作动态绑定，一般是指在执行期间（非编译期间）判断引用对象的实际类型，根据实际类型判断并调用相应的属性和方法。主要用于继承父类和实现接口时，父类引用指向子类对象。
同一个对象，方法名相同，参数不同，执行过程和结果也不同。
运行时多态: 程序再运行期才确定，要执行那个对象的方法，称为运行时多态。
继承
重写覆盖
对象向上造型-父类引用指向子类对象
操作步骤:
上面的案例，我们发现，方法名就叫show,但是不同的对象:
New Tiger()->=执行就是tiger的方法;
New Lion() -> 执行这个方法就是调用 lion的方法；
而lion和tiger的方法执行过程和结果是不同的。
相同的方法，对于不同对象来调用，执行过程和结果是不同的。这称为多态。
2选1
上面的案例，自己去实践一下。
去自定义一个应用场景，使用的操作步骤和我们上面的步骤一致；
抽象类与抽象方法.
在面向对象的概念中，知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如形状类是抽象的类，圆、三角形等是具体类
用abstract修饰的类就是抽象类。
抽象类是抽象方法的容器，如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。抽象类中也可以包含有非抽象的方法甚至抽象类中可以没有抽象方法（只要一个类不应该有具体对象，就应该是抽象类，不一定是有抽象方法的）
创建一个抽象形状类，里面有两个抽象方法，计算面积，计算周长。
创建两个子类，分别为圆形和正方形，在子类中实现[重写]父类抽象方法。
测试类，创建子类对象，调用方法输出结果
如果用来修饰一个方法，表示这个方法不能被重写。
final来修饰一个类，表示这个类不能被继承。
例如: java.lang.String就是final类;大家可以找找其他的final类.
实现多继承；
设计，标准制定。
成员变量方面，在接口中只存在公开静态常量（即便没有使用static final修饰，Java也会默认确定其性质）
成员方法方面，在接口中只存在公开抽象方法（即便没有abstract修饰，Java也会默认其抽象性质）
package day12;
/**
* interface 关键字
* 接口不能直接实例化
*
* @author Administrator
*
*/
public interface IA {
//1 公共常量
// The blank final field a may not have been initialized
// int a; //和类不同的地方
int a = 1;
final int b = 1;
static final int c = 1;
public static final int d = 1;
//2 抽象方法
public abstract void t1();
abstract void t2();
void t3();
//3 默认方法
default void t4() {
System.out.println("jdk1.8 default method!");
}
//4 静态方法
static void t5() {
System.out.println("static method!");
}
}
规约：
一个类可以实现多个接口:
Class 类名 implements 接口1，接口2，接口3 …
类中要实现接口中的抽象方法。
或者不实现的话，这个类就要定义为抽象类.
package com.inters;
/**
* 接口不能直接进行实例化
* @author Administrator
*
*/
public interface IFly {
void fly();
}
package com.inters;
public interface IEat {
void eat();
}
package com.inters;
/**
* implements 实现 @Override重写接口的方法
*
* @author Administrator
*
*/
public class Bird implements IFly, IEat {
@Override
public void fly() {
System.out.println("笨鸟在飞");
}
// alt+/
@Override
public void eat() {
System.out.println("笨鸟在吃虫子");
}
}
package com.inters;
public class TestBird {
public static void main(String[] args) {
Bird bird = new Bird();
bird.eat();
bird.fly();
IFly bird2 = new Bird();
bird2.fly();
}
}
一个接口能继承一个接口吗？
一个接口可以继承多个接口吗？
如果一个类，继承了类同时有实现了接口，语法是什么样子的？
package enumdemo;
public enum EnumSex {
男, 女, 保密
}
package enumdemo;
public enum Color {
// 7个颜色
Red("红色", 1), Green("绿色", 2), Blue("蓝色", 3);
private String name;
private int index;
private Color(String name, int index) {
this.name = name;
this.index = index;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
吃: 人:[大人 小孩 猪 ]
创建父类;创建父类的方法；创建子类，重写父类的方法；父类引用作为参数；传递子类对象给方法；
Eg:昨天的作业:
Plantuml:
统一建模语言(Unified Modeling Language，UML)是一种为面向对象系统的产品进行说明、可视化和编制文档的一种标准语言，是非专利的第三代建模和规约语言。UML是面向对象设计的建模工具，独立于任何具体程序设计语言。
https://plantuml.com/zh/eclipse
以上是脚本宝典为你收集整理的12.11全部内容，希望文章能够帮你解决12.11所遇到的问题。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。