1 构造方法重载
在一个类内部，编写多个构造方法，创建对象的时候，根据需求的不同，调用不同的构造方法创建对象，实现不同的初始化。
案例：Demo1
public class Demo1 {
public static void main(String[] args) {
// 长方体
Box box1 = new Box(100,60,90);
box1.show();
box1.showTiji();
// 正方体
Box box2 = new Box(100);
box2.show();
box2.showTiji();
}
}
class Box{
//属性
int length;
int width;
int height;
//构造方法
//长方体
Box(int length,int width,int height){
this.length = length;
this.width = width;
this.height = height;
}
//正方体
Box(int length){
this.length = length;
this.width = length;
this.height = length;
}
//方法：
void show(){
System.out.println(length+","+width
+","+height);
}
void showTiji(){
int result = length * width * height;
System.out.println("体积是"+result);
}
}
public class Demo2 {
public static void main(String[] args) {
Customer cus1 =
new Customer("韩信",33,"将军");
cus1.show();
Customer cus2 =
new Customer("李白",21,"诗人",
"123","洛阳","bai@126.com");
cus2.show();
cus2.showAll();
}
}
class Customer{
//属性
String name;
int age;
String job;
String password;
String address;
String email;
//构造方法
Customer(String name,int age,
String job){
this.name = name;
this.age = age;
this.job = job;
}
Customer(String name,int age,
String job,String password,
String address,String email){
this.name = name;
this.age = age;
this.job = job;
this.password = password;
this.address = address;
this.email = email;
}
//方法
void show(){
System.out.println(name+","+age+","
+job);
}
void showAll(){
System.out.println(name+","+age+","
+job+","+password+","+address
+","+email);
}
}
2 static
静态的，可以用来修饰属性，方法以及代码块。
1）静态变量(静态属性)：使用static修饰的属性，称为静态变量，静态变量在内存中单独开辟存储空间，不依赖于对象而存在，可以通过类名.静态变量名直接进行访问。
访问方式：
类名.静态变量名
或者
对象名.静态变量名
案例：Demo3
public class Demo3 {
public static void main(String[] args) {
//类名.静态变量名
System.out.println(Foo.name);
// System.out.println(Foo.age);
//age是一个普通属性，只有在创建对象以后，才会为age
//属性开辟存储空间。必须先有对象，然后才可以访问age
//属性
//对象名.静态变量名
Foo foo = new Foo();
System.out.println(foo.name);
System.out.println(foo.age);
}
}
class Foo{
//静态变量不依赖于对象而存在，内存中单独开辟存储空间，
//可以通过类名.静态变量名直接访问。
static String name = "张三";//静态变量
int age = 21;//普通属性
}
2）静态方法：使用static修饰的方法，称为静态方法，不依赖于对象而存在，可以通过类名.静态方法名(参数)直接访问。
案例：Demo4
public class Demo4 {
public static void main(String[] args) {
//类名.静态方法名(参数)
Koo.f1();
//对象名.静态方法名(参数)
Koo koo = new Koo();
koo.f1();
}
}
class Koo{
static void f1(){
System.out.println("今天天气很好！");
}
}
访问方式：
类名.静态方法名(参数)
或者
对象名.静态方法名(参数)
3）如果main方法跟静态方法在同一个类中，在main方法中，可以直接使用静态方法名(参数)来访问静态方法。
案例：Demo5
public class Demo5 {
static void f1(){
System.out.println("今天风真大！");
System.out.println("静态方法");
}
public static void main(String[] args) {
f1();
}
}
public class Demo6 {
public static void main(String[] args) {
for(int i=1;i<=100;i++){
double num = Math.random();
System.out.println(num);
}
}
}
4）sun设计的工具类中经常使用到静态方法，用户可以不用创建该工具类的对象，就可以访问这些静态方法，使用方便。
Math（数学）是sun公司设计的一个工具类，Math内部所有的方法都是静态方法。
random():是一个静态方法，用来返回一个随机的小数，取值范围在[0.0,1.0)
案例：Demo7
public class Demo7 {
//创建一个double类型数组ary，包含200个元素，通过
//Math.random()生成的随机给数组元素赋值。最后
//使用两种for循环，输出每一个元素的值。
public static void main(String[] args) {
double[] ary = new double[200];
for(int i=0;i<=ary.length-1;i++){
ary[i] = Math.random();
}
for(int i=0;i<=ary.length-1;i++){
System.out.println(ary[i]);
}
System.out.println();
System.out.println();
System.out.println();
for(double num : ary){
System.out.println(num);
}
}
}
public class Demo8 {
//在main方法中，创建一个包含了100个元素的double
//类型的数组，使用Math.random()生成的随机数给
//数组元素赋值。
//1 使用两种for循环输出每一个元素的值
//2 求出所有元素的累加之和
//3 求出元素的平均值
public static void main(String[] args) {
double[] ary = new double[100];
for(int i=0;i<=ary.length-1;i++){
ary[i] = Math.random();
System.out.println(ary[i]);
}
System.out.println();
for(double num:ary){
System.out.println(num);
}
double sum = 0;
for(double num:ary){
sum = sum + num;
}
System.out.println("累加之和："+sum);
double avg = sum/100;
System.out.println("平均值是："+avg);
}
}
5）代码块：使用{}括起来的一段代码，每次创建对象的时候都会默认的调用代码块一次。
案例：Demo9
public class Demo9 {
public static void main(String[] args) {
Eoo eoo1 = new Eoo();
Eoo eoo2 = new Eoo();
Eoo eoo3 = new Eoo();
}
}
class Eoo{
{
System.out.println("海阔天空");
System.out.println("我变了 我没变");
System.out.println("喜欢你");
}
}
6）静态代码块：使用static修饰的代码块称为静态代码块，不管创建该类多少个对象，静态代码块只执行一次。
案例：Demo10
public class Demo10 {
public static void main(String[] args) {
Moo moo1 = new Moo();
Moo moo2 = new Moo();
Moo moo3 = new Moo();
}
}
class Moo{
static{
System.out.println("围城");
System.out.println("幻城");
System.out.println("三重门");
}
}
经常使用静态代码块来保存连接数据库的信息，比如密码...
3 this
当前的，现在的
1）this.属性：指代当前的属性。
2）this(参数)：在当前的构造方法中，调用本类中其他的构造方法。跟构造方法重载结合使用。
必须在当前构造方法的第1行使用。
案例：Demo11
public class Demo11 {
public static void main(String[] args) {
Person p1 =
new Person("乔峰",33,"帮主",
"襄阳","feng@126.com");
p1.show();
}
}
class Person{
//属性
String name;
int age;
String job;
String address;
String email;
//构造方法
Person(String name,int age,String job,
String address){
this.name = name;
this.age = age;
this.job = job;
this.address = address;
}
//给每一个属性赋值
Person(String name,int age,String job,
String address,String email){
//this(参数)：在当前的构造方法中调用本类中其他的
//构造方法。必须在当前构造方法的第1行使用。
this(name,age,job,address);
this.email = email;
}
//方法：
void show(){
System.out.println(name+","+age+","
+job+","+address+","+email);
}
}
public class Demo12 {
public static void main(String[] args) {
User user =
new User("张三",29,"经理",
"abc",30000.99,"北京");
user.show();
user.showAll();
}
}
class User{
//属性
String name;
int age;
String job;
String password;
double salary;
String address;
//构造方法
User(String name,int age,String job){
this.name = name;
this.age = age;
this.job = job;
}
User(String name,int age,String job,
String password,double salary,
String address){
this(name,age,job);
this.password = password;
this.salary = salary;
this.address = address;
}
//方法
void show(){
System.out.println(name+","+age+","
+job);
}
void showAll(){
//this.方法名(参数)：在当前的方法中，调用本类中
//其他的方法
this.show();
System.out.println("密码："+password);
System.out.println("工资："+salary);
System.out.println("地址："+address);
}
}
3）this.方法名(参数)：在当前方法中调用本类的其他方法
4 继承
继承的本质就是代码的“复制”。
案例：Demo13
public class Demo13 {
public static void main(String[] args) {
Person2 p1 = new Person2();
p1.name = "李世民";
p1.age = 32;
p1.address = "长安";
p1.show();
Teacher t1 = new Teacher();
t1.name = "李治";
t1.age = 21;
t1.address = "洛阳";
t1.salary = 20000.1;
t1.email = "zhi@126.com";
t1.show();
t1.showAll();
}
}
class Person2{//父类
//属性
String name;
int age;
String address;
//方法
void show(){
System.out.println(name+","+age+","
+address);
}
}
//class 子类 extends 父类
class Teacher extends Person2{//子类
//属性：姓名，年龄，地址，工资，邮箱
//继承父类Person2中的姓名，年龄，地址
double salary;
String email;
//方法：
//继承父类中show()方法
void showAll(){
this.show();//调用父类中继承过来show()方法
System.out.println("工资："+salary);
System.out.println("邮箱："+email);
}
}
1）子类会继承父类中所有的属性和方法
2）格式：
class 子类 extends 父类{
继承父类的属性和方法
在子类中编写其他的属性和方法。
}
案例：Demo14
public class Demo14 {
public static void main(String[] args) {
Worker worker = new Worker();
worker.name = "张翠山";
worker.job = "大侠";
worker.age = 31;
worker.address = "冰火岛";
worker.phone = "13333333333";
worker.salary = 200000.1;
worker.show();
worker.showYearSal();
worker.showAll();
}
}
class Emp{
//属性
String name;
int age;
String job;
double salary;
//方法
void show(){
System.out.println(name+","+age+","+
job+","+salary);
}
void showYearSal(){
double result = salary * 12;
System.out.println(name+"的年薪是"+
result);
}
}
//设计一个父类Emp
//属性：姓名，年龄，职位，工资
//方法：void show():输出姓名，年龄，职位，工资
//void showYearSal():输出姓名和年薪（工资*12）
class Worker extends Emp{
//属性
String address;
String phone;
//方法
void showAll(){
this.show();
System.out.println("地址："+address);
System.out.println("电话："+phone);
}
}
3）Java中永远是单继承，一个子类只能有一个直接的父类，但是可以层层继承。
案例：Demo15
public class Demo15 {
public static void main(String[] args) {
Foo4 foo = new Foo4();
System.out.println(foo.num1);
System.out.println(foo.num2);
System.out.println(foo.num3);
System.out.println(foo.num4);
}
}
class Foo1{
int num1=100;
}
class Foo2 extends Foo1{
//num1
int num2=200;
}
class Foo3 extends Foo2{
//num1,num2
int num3=300;
}
class Foo4 extends Foo3{
//num1,num2,num3
int num4=400;
}