知识点
创建一个对象之前需要做点准备工作
1.构造方法
2.静态变量
3.静态方法 必须主动调用才执行
代码块：
在对象创建之前就有限会被调用
类里面可以有多个代码块
执行顺序和出现的先后顺序相同
尽量不要在类里面写多个代码块
修饰符(可以没有，有就是static) {
预先执行的内容
}
| 位置 | 作用 | |
|---|---|---|
| 局部代码块 | main里 | 给变量限定生命周期,局部代码块的变量在执行结束后会被java回收 |
| 构造代码块 | 类的成员位置 | 在每次执行构造方法前先执行构造代码块，可以将多个构造方法中的相同代码放到构造代码块中，对对象进行初始化 |
| 静态代码块 | 类的成员位置 | 一般用于给类初始化，被静态修饰的代码块仅执行一次 |
内部类
定义一个类可以在多个地方定义
1.单独创建一个文件管理一个类
2.直接在文件里面 类A的上面和下面创建
3.直接在某个类A内部创建一个类
一个类A依附于另一个类B
封装
- 类来封装属性和方法
- 访问权限Private public protected
继承
- A extends A就是B的子类 B就是A的父类
- 获得父类的方法和属性 并且需要添加自己的属性和方法
- Java只能单继承但可以变相多继承:A继承B,B继承C，A继承B与C
- 所有的类都是直接或者间接继承于Object类
- 当调用子类的一个方法时，如果没有就会到父类里面去查找
- 如果在子类里面需要调用父类的方法或者显示调用父类的属性和方法就使用 super
- 需要在一个方法里面调用super的对应方法的情况
1.父类做完之后，子类再操作
2.子类做点事情之后 再调用父类去完成
如果一个方法需要完成一个功能又不能单独完成，必须要父类做相应的工作
如果子类里面需要实现父类的方法 就需要重写
@override - 如果父类有自定义构造方法
- 子类的构造方法里面必修显示调用父类的构造方法
- 如果父类有内部类，子类中有同名内部类，那么父类中的内部类就被屏蔽了
- 如果非要使用父类中的内部类只能使用全类名
多态
1.同一个方法 多种实现=在不同的子类中有不同的实现
2.如果有继承关系：子类的对象可以使用父类变量接收
技术
instanceof运算符用于测试构造函数的prototype属性是否出现在对象的原型链中的任何位置
技术的使用
代码块
class Person{
int age;
{
age = 30;
System.out.println("代码块 age="+age);
}
//静态代码块
{
// age = 20; 静态代码块里不能调用成员变量和实例方法
System.out.println("代码块 age");
}
public Person(){
System.out.println("无参构造方法 age="+age);
}
public Person(int age){
this.age = age;
System.out.println("有参构造方法 ");
}
}
内部类
class RelativeLayout{
String view;
//在显示一个视图前 必须告诉系统这个视图的位置
public void show(LayoutParams layout){
System.out.println("视图"+view+"显示出来了");
System.out.println("left:"+layout.leftMergin+"top:"+layout.topMergin+"right:"+layout.rightMergin+"botton:"+layout.bottemMergin);
}
//定义一个内部类用于管理相对布局的具体布局属性
static class LayoutParams{
float leftMergin;
float topMergin;
float rightMergin;
float bottemMergin;
public LayoutParams(float leftMergin,float topMergin,float rightMergin,float bottemMergin){
this.leftMergin = leftMergin;
this.topMergin = topMergin;
this.rightMergin = rightMergin;
this.bottemMergin = bottemMergin;
}
}
}
class testLayout{
public static void main(String[] args){
//创建一个相对布局 容器视图
RelativeLayout r1 = new RelativeLayout();
r1.view ="分享按钮";
//显示这个视图
//准备好这个视图的布局属性
//1.
//RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(20,20, r1.show(params);
//使用匿名对象 只要使用一次
r1.show(new RelativeLayout.LayoutParams(20,20,20,20));
TestInner ti = new TestInner();
ti.test();
}
}
class TestInner{
int a;
int b;
Inner inner;
class Inner{
//费静态的内部类可以访问外部类的属性和方法
public Inner(){
a = 20;
b = 30;
show();
}
}
public void test(){
inner = new Inner();
}
public void show(){
System.out.println("a = "+a+" b = "+b);
}
}
继承
class Person1{
String name;
int age;
public Person1(String name,int age){
this.name = name;
this.age = age;
}
public void walk(){
System.out.println(name + "：走路");
}
public void eat(){
System.out.println(name + "：吃饭");
}
public class inners{
public void show(){
System.out.println("Person1 inner");
}
}
}
class Student extends Person1{
int id;
String school;
inners i;//说明内部类也可以被继承
public class inners{
public void show(){
System.out.println("Person1 inner");
}
}
public Student(String name,int age,int id,String school){
super(name,age);
this.id = id;
this.school = school;
}
public void show(){
System.out.println("name:"+name);
}
//方法的重写
@Override
public void walk() {
//super.walk();
System.out.println("快走");
}
@Override
public void eat() {
System.out.println("快吃");
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
", school='" + school + '\'' +
'}';
}
}
class TestExtends{
public static void main(String[] args){
/**Student xw = new Student();
xw.name = "小王";
xw.age = 20;
xw.id = 001;
xw.school = "斯坦福";*/
Student xw = new Student("小王",20,001,"斯坦福");
//xw.show();
xw.walk();
xw.eat();
System.out.println(xw);
C testc = new C();
A testc2 = new C();
testc2.info();
}
}
多态
class A{
public void info(){
System.out.println("in A");
}
}
class B extends A{
@Override
public void info() {
System.out.println("in B");
}
}class C extends A{
@Override
public void info() {
System.out.println("in C");
}
}
instanceof运算符
if(p instanceof CivilServant)//判断P是否在CivilServant内
{
}
技术的实际使用
要求：
定义一个Person类：name age
提供有参数的构造方法
walk方法
eat方法
公务员：salary ，看杂志数量，show
公司职员：salary， tec show
创建多个职员和公务员 放到一个数组里面输出
将数组里面所有人的信息输出
实现：
public class Person {
String name;
int age;
public void walk(String name){
this.name = name;
System.out.println(name+"走路");
}
public void eat(String name){
this.name = name;
System.out.println(name+"吃饭");
}
}
class CivilServant extends Person {
int Salary;
int Reading;
public CivilServant(String name,int age,int Salary,int Reading){
this.name = name;
this.age = age;
this.Salary = Salary;
this.Reading = Reading;
}
public void walk(){
System.out.println(name+"慢慢走");
}
public void eat(){
this.name = name;
System.out.println(name+"慢慢吃");
}
public void show(){
this.Salary = Salary;
this.Reading = Reading;
System.out.println("姓名："+name);
System.out.println("年龄："+age);
System.out.println("工资："+Salary);
System.out.println("阅读量："+Reading);
}
}
class Staff extends Person {
int Salary;
String Tec;
public Staff(String name,int age,int Salary,String Tec){
this.name = name;
this.age = age;
this.Salary = Salary;
this.Tec = Tec;
}
public void walk() {
//super.walk();
System.out.println("快走");
}
public void eat(){
this.name = name;
System.out.println(name+"快吃");
}
public void show(){
this.Salary = Salary;
this.Tec = Tec;
System.out.println("姓名："+name);
System.out.println("年龄："+age);
System.out.println("工资："+Salary);
System.out.println("技术："+Tec);
}
}
import java.util.ArrayList;
public class Output {
public static void main(String[] args){
ArrayList<Person> peoples = new ArrayList<>();
Person c1 = new CivilServant("J",20,8000,10);
Person c2 = new CivilServant("K",25,9000,15);
peoples.add(c1);
peoples.add(c2);
Person s1 = new Staff("Z",20,15000,"C");
Person s2 = new Staff("Y",25,25000,"C++");
peoples.add(s1);
peoples.add(s2);
for(Person p: peoples){
if(p instanceof CivilServant)
{
CivilServant c = (CivilServant)p;
c.show();
System.out.println();
}
else{
Staff s = (Staff)p;
s.show();
System.out.println();
}
}
}
}
随笔
果然，写小型demo还是要轻松得多。大型demo先不说绕去绕来的各种循环或者判断，光是数不清的变量就足够让我头大了，就像夏洛特烦恼的经典场景 马什么冬梅一样，先前的定义的变量，到后面再次调用，需要调用的啥？调用的是哪一个....确实是一个让人秃头的问题
