面向对象
什么是面向对象
回顾方法的定义
package objectOriented;
import java.io.IOException;
//回顾方法的定义
public class Demo01 {
public static void main(String[] args) {
}
public static String sayHello(){
return "Hello,World!";
}
public int max(int a,int b){
return a>b ? a:b;
}
public void readFile(String file) throws IOException{
}
}
回顾方法的调用
package objectOriented;
public class Student {
//静态方法
public static void say(){
System.out.println("学生说话");
}
//非静态方法
public void pillowTalk(){
System.out.println("学生说悄悄话");
}
}
package objectOriented;
//回顾方法的调用
public class Demo02 {
public static void main(String[] args) {
Student.say();//静态方法调用
Student student = new Student();
student.pillowTalk();//非静态方法调用
}
//和类一起加载的
// public static void a(){
// b();
// }
//类实列话之后才存在
// public void b(){
//
// }
//区分实参和形参
public static int add(int a,int b){
return a+b;
}
}
package objectOriented;
//值传递
public class Demo03 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
change(a);
System.out.println(a);
}
public static int change(int a){
a=10;
return a;
}
}
package objectOriented;
//引用传递
public class Demo04 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
change(person);
System.out.println(person.name);
}
public static void change(Person person){
person.name = "张三";
}
}
class Person{
String name;
}
类与对象的关系
package objectOriented;
public class Student {
String name;
int age;
//方法
//静态方法
public static void say(){
System.out.println("学生说话");
}
//非静态方法
public void pillowTalk(){
System.out.println("学生说悄悄话");
}
public void study(){
System.out.println(this.name + "在学习");
}
}
package objectOriented;
public class Demo05 {
public static void main(String[] args) {
//类实例化
//类实例化后返回一个自己的对象
Student student = new Student();
student.study();
}
}
构造器详解
package objectOriented;
public class Person {
String name;
//无参构造器
public Person(){
}
//alt+insert
//构造器（有参）
public Person(String name){
this.name=name;
}
}
创建对象内存分析
简单小结类与对象
封装详解
package objectOriented2;
public class Student {
//属性私有
private String name;
private int id;
private char sex;
//提供一些public的get，set的方法
//alt+insert
public String getName(){
return this.name;
}
public int getId(){
return this.id;
}
public char getSex(){
return this.sex;
}
public void setName(String name){
this.name = name;
}
public void setId(int id){
this.id = id;
}
public void setSex(char sex) {
this.sex = sex;
}
}
什么是继承
package objectOriented2;
public class Person {
//public
//protected
//default
//private
public void say(){
System.out.println("人在说话");
}
}
package objectOriented2;
//子类继承了父类，就会有父类的全部方法
public class Student extends Person{
//属性私有
private String name;
private int id;
private char sex;
//提供一些public的get，set的方法
//alt+insert
public String getName(){
return this.name;
}
public int getId(){
return this.id;
}
public char getSex(){
return this.sex;
}
public void setName(String name){
this.name = name;
}
public void setId(int id){
this.id = id;
}
public void setSex(char sex) {
this.sex = sex;
}
}
package objectOriented2;
public class Demo01 {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
Super详解
package objectOriented2;
public class Person {
//public
//protected
//default
//private
public String name = "Person";
}
package objectOriented2;
//子类继承了父类，就会有父类的全部方法
public class Student extends Person{
public String name = "Student";
public Student(){
super();//调用父类的无参构造
}
public void print1(){
System.out.println(this.name);
}
public void print2(){
System.out.println(this.name);
System.out.println(super.name);
}
}
package objectOriented2;
public class Demo01 {
public static void main(String[] args) {
Student student = new Student();
student.print1();
student.print2();
}
}
方法重写
package objectOriented2;
public class B {
public static void test1(){
System.out.println("B->test()");
}
public void test2(){
System.out.println("B->test()");
}
}
package objectOriented2;
public class A extends B {
public static void test1(){
System.out.println("A->test()");
}
public void test2(){
System.out.println("A->test()");
}
}
package objectOriented2;
public class Demo02 {
public static void main(String[] args) {
//静态方法： 方法的调用只和左边定义的数据类型有关
//非静态：重写
A a = new A();
B b = new A();
a.test1();
b.test1();
a.test2();
b.test2();
}
}
多态
package objectOriented3;
public class Person {
public void run(){
System.out.println("run");
}
}
package objectOriented3;
public class Student extends Person{
public void run(){
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
package objectOriented3;
public class Demo01 {
public static void main(String[] args) {
//能调用的方法都是自己的或继承父类的
Student s1 = new Student();
//可以指向子类，但不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
s1.run();
s2.run();
s1.eat();
//s2.eat();
}
}
instanceof和类型转换
package objectOriented3;
public class Person extends Object{
}
package objectOriented3;
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
package objectOriented3;
public class Teacher extends Person{
}
package objectOriented3;
public class Demo01 {
public static void main(String[] args) {
Object object = new Student();
System.out.println(object instanceof Student);
System.out.println(object instanceof Person);
System.out.println(object instanceof Object);
System.out.println(object instanceof Teacher);
System.out.println(object instanceof String);
Person student1 = new Student();
//System.out.println(person instanceof String);//编译报错
((Student)student1).go();//父类转化为子类
Person student2 = new Student();
Person person = student2;//子类转化为父类会丢失一些方法或属性
}
}
static关键字详解
package objectOriented3.Demo02;
import java.sql.SQLOutput;
//如果被final修饰则不能被继承
public class Person {
//2:赋初始值
{
System.out.println("匿名代码块");
}
//1:只执行一次
static{
System.out.println("静态代码块");
}
//3
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
}
}
package objectOriented3.Demo02;
public class Student {
private static int age;//静态变量，多线程，所有对象共享
private double score;//非静态变量
public void run(){
}
public static void go(){
}
public static void test(){
//run(); 非静态方法，不能在静态方法里被调用
go();
}
}
package objectOriented3.Demo02;
//静态导入包
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(random());
}
}
抽象类
package objectOriented3.Demo03;
//abstrac 抽象类
//抽象类的所有方法，继承了它的子类都必须实现它的方法，除非子类也是抽象类
//类只有单继承，但是接口可以多继承
public abstract class Action {
//抽象方法，只有名字，没有方法的实现
public abstract void doSomething();
}
package objectOriented3.Demo03;
//抽象类的所有方法，继承了它的子类都必须实现它的方法
public class A extends Action{
@Override
public void doSomething() {
}
}
接口的定义和实现
package objectOriented3.Demo04;
public interface UserService {
//接口中的所有定义方法都是抽象的公共的 public abstract
//接口中的所有定义属性都是常量 public static final
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package objectOriented3.Demo04;
public interface TimeService {
}
package objectOriented3.Demo04;
//利用接口可以”多继承“
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
内部类
package objectOriented3.Demo05;
public class Outer {
private int id = 1;
public void out(){
System.out.println("这是外部类的方法");
}
class Inner1{
public void in(){
System.out.println("这是内部类的方法");
}
public void getId(){
System.out.println(id);
}
}
// class static Inner2{
// public void in(){
// System.out.println("这是内部类的方法");
// }
// public void getId(){
// System.out.println(id);
// }
// }
}
package objectOriented3.Demo05;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner1 inner = outer.new Inner1();
inner.getId();
}
}
//一个java类里可以有多个class，但是只能有一个poublic class
class A{
}
