1：Math类的随机数(掌握)
类名调用静态方法。
包：java.lang
类：Math
方法：public static double random():
Java.lang包下的类是不用导包就可以直接使用的。
产生1-100之间的随机数：
int number = (int)(Math.random()*100)+1;
2：如何使用API。(掌握)
A:找到文档，打开文档。
B:点击左上角的显示变成隐藏，然后点击索引
C:你应该知道你要找谁?Math
所以，你就在那个输入框里面输入Math，然后回车，再回车。
D:看这个类的结构
java.lang
类 Math
java.util
类 Scanner
如果是java.lang包下的类，是可以直接使用的。(Math)，否则，就需要导包才能使用。(Scanner)
E:看看对这个类的说明。
F:看构造方法
名称：字段 -- 成员变量 -- 属性。
a:有构造方法，那么，就通过构造方法创建对象使用。
b:没有构造方法，那么，这个类的成员一般都是静态。
通过类名调用。
G:按照正常的操作使用方法。
左边：
是否静态：如果静态修饰，那么可以通过类名调用。否则，就必须创建对象调用。
是否有明确返回值：如果是void类型，就直接调用即可。否则，就可以输出或者赋值。
右边：
看方法名：不要写错了。
看参数：看参数类型及个数。
3：继承(掌握)extends
(1)把多个类中的相同的属性和行为进行抽取，封装到一个类中，然后再建立新类的时候，不需要从头做起，继承刚才定义的那个类即可。
(2)好处：
A:提高代码的复用性。
B:让类与类之间产生了一个关系，是多态的前提。
(3)什么时候使用继承?
A:如果类之间存在着:is a 的关系，就可以考虑使用继承。
B:不要为了继承部分功能，而去使用继承。详细见例子：
/*
继承一定要符合is a 的关系。
*/
class Demo5
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
class Animal
{
String name = "巴马";
int age = 80;
public void eat(){
System.out.println("吃");
}
public void sleep(){
System.out.println("睡");
}
private void method(){}
}
class Cat extends Animal {
public void climb(){
System.out.println("爬树");
}
public void catchM(){
System.out.println("抓耗子");
}
public void eatM(){
System.out.println("生吃耗子");
}
}
class Person extends Cat{} //不要为了人有“爬树”和“抓耗子”的工能，而去继承Cat类，语法上没有错误，但是在逻辑上有问题。因为Cat类还有“生吃耗子”工能，而人没有。
(4)继承的特点：
A:Java只支持单继承，不支持多继承。
为什么?如果支持多继承，就会有调用不明确的问题。
B:Java支持多层(重)继承。
例子：
/*
继承的特点：
支持单继承，不支持多继承。
支持多层继承。
Object是多有类的直接或间接父类。
*/
class Demo4
{
public static void main(String[] args)
{
Person p = new Person();
System.out.println(p.name);
System.out.println(p.age);
p.eat();
p.sleep();
}
}
class Animal
{
String name = "巴马";
int age = 80;
public void eat(){
System.out.println("吃");
}
public void sleep(){
System.out.println("睡");
}
private void method(){}
}
class Pig extends Animal{}
//class Person extends Monkey,Animal{} //一个类不能多继承
class Monkey extends Animal{}
class Person extends Monkey{} //支持多层继承
(5)super和this的区别?
A:super是一个关键字，代表父类的存储空间标识。(可以理解为父亲对象的引用，单实际不是父亲对象的引用)
B:它和this的用法相似
a:成员变量
this.变量 -- 本类的
super.变量 -- 父类的
b:构造方法
this(...) -- 本类的
super(...) -- 父类的
c:成员方法
this.方法名() -- 本类的
super.方法名() -- 父类的
例子：
/*
super：代表父类的内存空间
使用方式：
1、super区分父类成员变量与子类成员变量
2、super放在构造方法中第一行，用来调用父类的构造方法
*/
class Demo6
{
public static void main(String[] args)
{
//Person p = new Person();
//p.showMe();
Person p2 = new Person("巴豆",3);
p2.showMe();
}
}
class Animal
{
String name = "巴马";
int age = 80;
//定义空参构造
/*
public Animal(){
System.out.println("我是父类的空参构造方法");
}
*/
//定义两个参数构造
public Animal(String name,int age) {
System.out.println("我是父类的有参构造方法");
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃");
}
public void sleep(){
System.out.println("睡");
}
private void method(){}
}
class Person extends Animal
{
String name = "巴驴";
int age = 60;
public Person(){
//super(); //默认都有super()构造方法
super("aaa",100);
System.out.println("我是子类的空参构造方法");
}
public Person(String name,int age) {
//this(); //this不可以与super同时调用构造方法
super(name,age);
System.out.println("我是子类的有参构造方法");
this.name = name;
this.age = age;
}
public void showMe(){
String name = "巴骡";
int age = 70;
//局部变量直接写变量名即可
System.out.println("姓名："+name+" 年龄："+age);
//本类的成员变量加this区分
System.out.println("姓名："+this.name+" 年龄："+this.age);
//父类的成员变量加super区分
System.out.println("姓名："+super.name+" 年龄："+super.age);
//如果同时存在，则就近原则
}
}
(6)继承关系内存图：
（7）子父类实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数，原因是构造方法中第一行默认的super()，子类具备父类中的数据，所以需要先明确父类是如何初始化的，即调用父类的构造方法。父类存储空间优于子类对象。
大致顺序：
（8）标准的继承关系代码
/*
标准的继承关系代码
*/
class Demo9
{
public static void main(String[] args)
{
Cat cat = new Cat("Tom",5,"黄黑条");
cat.method();
cat.method2();
cat.setName("kitty");
cat.setColor("pink");
cat.showMe();
}
}
class Animal
{
private String name;
private int age;
public Animal() {}
public Animal(String name,int age) {
this.name = name;
this.age = age;
}
public void method(){
System.out.println("我是父类的第一个方法");
}
public void method2(){
System.out.println("我是父类的第二个方法");
}
//-----------------------------------------------------------------
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
class Cat extends Animal
{
private String color;
public Cat() {}
public Cat(String name,int age,String color) {
super(name,age);
this.color = color;
}
public void method(){
System.out.println("我是子类的重写的第一个方法");
}
public void showMe(){
System.out.println("name:"+super.getName()+" age:"+getAge()+" color:"+color);
}
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
}
(9)子父类中成员变量的用法：
A:名称不同，这个太简单了。
B:名称相同，子类对象的在使用的时候：
先找子类局部范围
再找子类成员范围
最后找父类成员范围
父类的父类成员范围
(10)子父类中成员方法的用法：
A:名称不同，这个太简单了。
B:名称相同，子类对象的在使用的时候：
先找子类的
再找父类的
C：方法重写（overiding）
要求：
a.子类方法访问权限需要大于等于父类方法访问权限
b.返回值类型：
基本类型/void:必须相同
引用类型：子类返回值类型必须为父类返回值类型的子类
c.函数名相同
d.参数列表：相同为重写，不同时为重载
应用：子类需要父类功能，但又在功能上又有多增加时，可以复写父类方法。子类比父类更强大。
注意事项：
a.父类中私有方法不可以被覆盖。
b.在子类中想调用父类自己的方法可以使用super关键字
c.静态只能覆盖静态。(这个不能算，因为静态跟类相关)
例子：
class OveridingMethod {
public static void main(String[] args) {
Zi2 zi2 = new Zi2();
zi2.method2();
}
}
class Fu {
public void method() {
}
}
class Zi extends Fu {
public void method() {
}
}
class Fu2 {
Fu fu = new Fu();
public Zi method2() { ////报错，子类返回值类型必须为父类返回值类型的子类，此处不是。
System.out.println("我是子类2的方法");
return zi;
}
}
class Zi2 extends Fu2 {
Zi zi = new Zi();
public Fu method2() { //报错，子类返回值类型必须为父类返回值类型的子类，此处不是。
System.out.println("我是子类2的方法");
return fu;
}
}
(11)子父类中构造方法的用法：
A:子类的初始化过程中，首先回去执行父类的初始化动作。
因为子类的构造方法中默认有一个super()。
为什么?子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。
所以，子类的初始化过程中，会先执行父类的初始化。
B:如果父类没有无参构造方法
A:使用super调用父类的带参构造。推荐方式。
B:使用this调用本身的其他构造。
4：代码块(面试题)
（1）代码块：写代码的区域，使用{}作为范围限定
局部代码块：
位置：方法内
作用：控制变量作用域
构造代码块：
位置：成员位置，类中，方法外
作用：将构造器中相同代码抽取，在构造器前执行
静态构造代码块：
位置：成员位置，类中，方法外
作用：只在第一次创建对象时初始化一次
/*
代码块：写代码的区域，使用{}作为范围限定 局部代码块：
位置：方法内
作用：控制变量作用域
构造代码块：
位置：成员位置，类中，方法外
作用：将构造器中相同代码抽取，在构造器前执行
静态构造代码块：
位置：成员位置，类中，方法外
作用：只在第一次创建对象时初始化一次 默认初始化>显示初始化>构造代码块>构造方法
*/
class Demo2
{
public static void main(String[] args)
{
int i = 10;
{
int i2 = 20;
}
System.out.println(i);
//System.out.println(i2); 超出作用域 Person p = new Person();
Person p2 = new Person("巴马",80);
p2.showMe(); }
} class Person
{
//定义Person类的属性
private String name = "巴骡";
private int age = 60; //定义一个构造代码块
{
System.out.println("我是一个构造代码块");
name = "巴驴";
age = 70;
System.out.println("我是要初始化的步骤1");
System.out.println("我是要初始化的步骤2");
System.out.println("我是要初始化的步骤3");
System.out.println("我是要初始化的步骤4");
} static{
System.out.println("我是一个静态构造代码块");
} //定义Person类的构造方法
public Person(){
System.out.println("我是空参构造方法");
}
public Person(String name,int age){
System.out.println("我是有参构造方法");
//this.name = name;
//this.age = age;
} public void showMe(){
System.out.println("name:"+name+" age:"+age);
} //定义Person类的普通方法
public void eat(){
System.out.println("吃了");
} public void sleep(){
System.out.println("睡了");
}
//定义Person类的getters和setters
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
} public void setAge(int age) {
this.age = age;
} public int getAge(){
return age;
}
}
(2)执行顺序：
静态代码块 --> 构造代码块 --> 构造方法
默认初始化>显式初始化>构造代码块初始化>构造方法初始化
(3)注意事项：
静态代码块只执行一次
5：final(掌握)（简单总结为：修饰的东西不能变！）
(1)是一个关键字，可以用于修饰类，成员变量，成员方法。
(2)特点：
它修饰的类不能被继承。
它修饰的成员方法是不能被子类重写的。
它修饰的成员变量是一个常量。常量必须有值,且常量的值只能赋值一次。如果是成员变量，只需要在对象创建之前赋值即可。
引用类型常量可以更改其堆内存对象中的值。
例：
a.final修饰的类不能被继承。
class Demo10 {
public static void main(String[] args) {
}
}
final class Fu{ // 修饰类，类不可以被继承。
}
class Zi extends Fu{
}
b.它修饰的成员方法是不能被子类重写的.
class Demo10 {
public static void main(String[] args) {
}
}
class Fu{
final public void showMe(){} //修饰方法，方法不可以被重写。
}
class Zi extends Fu{
public void showMe(){}
}
c.常量必须有值
class Demo10 {
public static void main(String[] args) {
final int a;
System.out.println(a); //常量必须有值。此处会报错
}
}
d.常量的值只能赋值一次
class Demo10 {
public static void main(String[] args) {
final int a=10;
a=20; //常量的值只能赋值一次,此处报错
System.out.println(a);
}
}
e.如果是成员变量，只需要在对象创建之前赋值即可
class Demo10 {
public static void main(String[] args) {
Fu fu = new Fu("唐嫣"); //创建对象时赋值
}
}
class Fu {
//成员变量
final private String name;
final private int age = 20; //创建成员变量时赋值
//构造器
public Fu(String name) {
this.name = name;
}
}
f.引用类型常量可以更改其堆内存对象中的值，引用类型变量被final修饰，不能再指向其他对象地址
6：同一个文档里不能有两个以上Public修饰的类
public class name{}
public class age{} //同一个文档里有两个以上Public修饰的类会报错。
附：
题一：面向对象基础知识全涵盖例（标准学生类的定义及使用）
/*
标准学生类的定义及使用
*/
class Test
{
public static void main(String[] args)
{
/*
创建对象
使用对象调用方法
使用对象调用方法访问属性
*/
Student s = new Student();
s.setName("*");
s.setAge(24);
s.address = "上海，广州也可以！";
s.study("java");
System.out.println(s.eat());
System.out.println(s.hitBeanBean(3));
Student.jiayou("i have a dream，a code dream and a money dream！");
Student s2 = new Student("克强",26);
s2.study("SQL");
System.out.println(s2.eat());
System.out.println(s2.hitBeanBean(6));
Student.jiayou("i have a dream，a code dream and a money dream！");
}
}
/*
给类命名
成员变量的定义
构造方法的定义
普通方法的定义
getters/setters
*/
//给类命名
class Student
{
//成员变量的定义
private String name;
private int age;
public static String address = "北京，梦开始的地方!";
//构造方法的定义
public Student(){}
//一个参数的构造也可以定义
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//普通方法的定义
public void study(String neirong) {
System.out.println("我学的是"+neirong);
}
public String eat(){
return "我已经吃了！";
}
public String hitBeanBean(int cishu) {
return "我今天打了"+cishu+"次豆豆。我很舒服。";
}
public static void jiayou(String xuanyan) {
System.out.println(xuanyan);
}
//getters/setters
public void setName(String name) {
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge(){
return age;
}
}